home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / dev / src / td01_src.lha / td_r0.1 / source / td.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-06-20  |  237.3 KB  |  8,919 lines
  1. /*
  2. **      $VER: td.c 0.1 (20.6.99)
  3. **
  4. **      Creation date     : 11.4.1999
  5. **
  6. **      Description       :
  7. **         td library.
  8. **
  9. **
  10. **      Written by Stephan Bielmann
  11. **
  12. */
  13.  
  14. /*************************** Includes *******************************/
  15.  
  16. /*
  17. ** ANSI standart includes
  18. */
  19. #include <string.h>
  20. #include <math.h>
  21.  
  22. /*
  23. ** Amiga includes
  24. */
  25. #include <exec/types.h>
  26. #include <exec/memory.h>
  27. #include <dos/stdio.h>
  28. #include <dos/exall.h>
  29.  
  30. #include <clib/dos_protos.h>
  31. #include <clib/alib_stdio_protos.h>
  32.  
  33. #include <pragma/exec_lib.h>
  34.  
  35. /*
  36. ** Project includes
  37. */
  38. #include "td_private.h"
  39. #include "compiler.h"
  40. #include "pragma/x3_lib.h"
  41. //#include "include/td/tdbase.h"
  42.  
  43. /*************************** Defines ********************************/
  44.  
  45. #define EXALLBUFFERSIZE 2048    // Buffer size for exall dir scan
  46.  
  47. /********************** Private constants ***************************/
  48.  
  49. /*
  50. ** The library information structure
  51. */
  52. TDlibraryinfo *tdlibinfos=NULL;
  53.  
  54. /*
  55. ** The supported file format arrays
  56. */
  57. static STRPTR     *c3dsLib=NULL;
  58. static STRPTR    *c3dsNames=NULL;
  59. static STRPTR    *c3dsExt=NULL;
  60. static STRPTR     *c3dlLib=NULL;
  61. static STRPTR    *c3dlNames=NULL;
  62.  
  63. //!!!!!!!!!!!!! alles in base !! globales zeug !!!!!!!!!!!!!!!!!!
  64.  
  65. //dummi hummi
  66. /*
  67. static ULONG c3dFFIDs [] = { 0 };
  68.  
  69. static STRPTR  c3dFFLib [] = {
  70.     "dxf.library",
  71.     NULL
  72. };
  73.  
  74. static STRPTR c3dFFNames [] = {
  75.     "AutoCAD DXF",
  76.     NULL
  77. };
  78.  
  79. static STRPTR c3dFFExtensions [] = {
  80.     "dxf",
  81.     NULL
  82. };
  83.  
  84. static ULONG  c2dFFIDs   [] = {
  85.     T2DFEPS,
  86.     0
  87. };
  88.  
  89. static STRPTR c2dFFNames [] = {
  90.     "Encapsulated PostScript",
  91.     NULL
  92. };
  93.  
  94. static STRPTR c2dFFExtensions [] = {
  95.     "eps",
  96.     NULL
  97. };
  98. */
  99.  
  100. /*
  101. ** The constant supported drawing mode arrays
  102. */
  103. static ULONG  cDMIDs   [] = {
  104.     DMPOINTS,
  105.     DMWIREBW,
  106.     DMWIREGR,
  107.     DMWIRECL,
  108.     DMHIDDBW,
  109.     DMHIDDGR,
  110.     DMHIDDCL,
  111.     DMSURFBW,
  112.     DMSURFGR,
  113.     DMSURFCL,
  114.     0
  115. };
  116.  
  117. static STRPTR  cDMNames   [] = {
  118.     "Points, black and white",
  119.     "Wireframe, black and white",
  120.     "Wireframe, gray scales",
  121.     "Wireframe, colors",
  122.     "Hidden line, black and white",
  123.     "Hidden line, gray scales",
  124.     "Hidden line, colors",
  125.     "Surface, black and white",
  126.     "Surface, gray scales",
  127.     "Surface, colors",
  128.     NULL
  129. };
  130.  
  131. /*
  132. ** Definition of PI
  133. */
  134. #define PI 3.14159265359
  135.  
  136. /********************** Global variables ****************************/
  137.  
  138. struct x3Base *x3Base = NULL;
  139.  
  140. /********************** Private functions ***************************/
  141.  
  142. /********************************************************************\
  143. *                                                                    *
  144. * Name         : addMaterialNode                                     *
  145. *                                                                    *
  146. * Description  : Add a new material node to the space.               *
  147. *                                                                    *
  148. * Arguments    : space  IN : Pointer to the space.                   *
  149. *                type   IN : Type of material.                       *
  150. *                                                                    *
  151. * Return Value : Index of the new material or 0 if no more memory.   *
  152. *                                                                    *
  153. * Comment      : The array indices are beginnning at 0, index at 1   *
  154. *                                                                    *
  155. \********************************************************************/
  156. static ULONG addMaterialNode(TDspace *space,TDenum type) {
  157.     TDmaterialnode        *mat=NULL;
  158.     TDsurface            *surf=NULL;
  159.     TDtexture            *tex=NULL;
  160.     UBYTE                buffer[100];
  161.     ULONG                matnode,matblock;
  162.     ULONG                realmat;
  163.     
  164.     // check if we have still place for a material node
  165.     matnode=(space->materials.numberOfMaterials)%Ci_MATNODESINBLOCK;
  166.     matblock=((space->materials.numberOfMaterials)-matnode)/Ci_MATNODESINBLOCK;
  167.  
  168.     // we are above our internal limit
  169.     if(matblock>=Ci_MATBLOCKS) return(0);
  170.  
  171.     // check if we have to allocate a new nodes list block
  172.     if(matnode==0) {
  173.         space->materials.blocks[matblock]=AllocPooled(space->matblockspool,sizeof(TDmaterialblock));
  174.         if(space->materials.blocks[matblock]==NULL) return(0);
  175.     }
  176.  
  177.     mat = AllocMem(sizeof(TDmaterialnode),MEMF_FAST);
  178.     if (mat==NULL) {
  179.         return(0);
  180.     }
  181.  
  182.     mat->name=NULL;
  183.     sprintf(buffer,"tdMAT%ld",space->materials.numberOfMaterials);
  184.     mat->name = AllocVec(strlen(buffer)+1,MEMF_FAST);
  185.     if (mat->name==NULL) {
  186.         FreeMem(mat,sizeof(TDmaterialnode));
  187.         return(0);
  188.     }
  189.     strcpy(mat->name,buffer);
  190.  
  191.     //create the desired type of material
  192.     switch(type) {
  193.         case TD_SURFACE :
  194.             surf=AllocVec(sizeof(TDsurface),MEMF_FAST);
  195.             if(surf!=NULL) {
  196.                 surf->ambientColor.r=0;
  197.                 surf->ambientColor.g=0;
  198.                 surf->ambientColor.b=0;
  199.                 surf->diffuseColor.r=0;
  200.                 surf->diffuseColor.g=0;
  201.                 surf->diffuseColor.b=0;
  202.                 surf->shininess=0;
  203.                 surf->transparency=0;
  204.  
  205.                 realmat=(ULONG)surf;
  206.             } else {
  207.                 realmat=0;
  208.             }
  209.             break;
  210.  
  211.         case TD_TEXTURE :
  212.             tex=AllocVec(sizeof(TDtexture),MEMF_FAST);
  213.             if(tex!=NULL) {
  214.                 realmat=(ULONG)tex;
  215.             } else {
  216.                 realmat=0;
  217.             }
  218.             break;
  219.  
  220.         default :
  221.             realmat=0;
  222.             break;
  223.     }
  224.  
  225.     if(realmat==0) {
  226.         FreeVec(mat->name);
  227.         FreeMem(mat,sizeof(TDmaterialnode));
  228.         return(0);
  229.     }
  230.  
  231.     mat->handle=realmat;
  232.     mat->type=type;
  233.  
  234.     // last increment the numberOfMaterials counter and index assignment
  235.     mat->index=++(space->materials.numberOfMaterials);
  236.  
  237.     // assign the node to the nodes list
  238.     space->materials.blocks[matblock]->nodes[matnode]=mat;
  239.  
  240.     return(mat->index);
  241. }
  242.  
  243. /********************************************************************\
  244. *                                                                    *
  245. * Name         : getMaterialNode                                     *
  246. *                                                                    *
  247. * Description  : Search the material its node with its index, in     *
  248. *                the given space. If the index is not valid, NULL    *
  249. *                will be returned.                                   *
  250. *                                                                    *
  251. * Arguments    : space          IN : Pointer to the space            *
  252. *                materialindex  IN : Material index                  *
  253. *                                                                    *
  254. * Return Value : Pointer to the material or NULL if not found.       *
  255. *                                                                    *
  256. * Comment      : The array indices are beginnning at 0, index at 1   *
  257. *                                                                    *
  258. \********************************************************************/
  259. static TDmaterialnode *getMaterialNode(TDspace *space, ULONG materialindex) {
  260.     ULONG matblock,matnode;
  261.  
  262.     // if we have materials, and the index is between 1 and numberOfMaterials
  263.     if(space->materials.numberOfMaterials==0) return(NULL);
  264.     if(materialindex<1 || materialindex>space->materials.numberOfMaterials) return(NULL);
  265.  
  266.     // internal index is index - 1
  267.     materialindex--;
  268.  
  269.     // compute the block and node and return the material node
  270.     matnode=materialindex%Ci_MATNODESINBLOCK;
  271.     matblock=(materialindex-matnode)/Ci_MATNODESINBLOCK;
  272.     return(space->materials.blocks[matblock]->nodes[matnode]);
  273. }
  274.  
  275. /********************************************************************\
  276. *                                                                    *
  277. * Name         : mul33Matrix                                         *
  278. *                                                                    *
  279. * Description  : Multiplicates two 3x3 matrix structures.            *
  280. *                                                                    *
  281. * Arguments    : m1  IN/OUT : The first matrix, contains the result  *
  282. *                m2  IN     : The second matrix.                     *
  283. *                                                                    *
  284. * Comment      :                                                     *
  285. *                                                                    *
  286. \********************************************************************/
  287. static VOID mulMatrix (double m1[3][3], double m2[3][3]) {
  288.     double m[3][3];
  289.     int x,y,yy;
  290.  
  291.     for(x=0;x<3;x++) {
  292.         for(y=0;y<3;y++) {
  293.             m[x][y]=0;
  294.         }
  295.     }
  296.  
  297.     for(x=0;x<3;x++) {
  298.         for(y=0;y<3;y++) {
  299.             for(yy=0;yy<3;yy++) {
  300.                 m[x][y]+=m1[yy][y]*m2[x][yy];
  301.             }
  302.         }
  303.     }
  304.  
  305.     m1[0][0]=m[0][0];
  306.     m1[1][0]=m[1][0];
  307.     m1[2][0]=m[2][0];
  308.     m1[0][1]=m[0][1];
  309.     m1[1][1]=m[1][1];
  310.     m1[2][1]=m[2][1];
  311.     m1[0][2]=m[0][2];
  312.     m1[1][2]=m[1][2];
  313.     m1[2][2]=m[2][2];
  314. }
  315.  
  316. /********************************************************************\
  317. *                                                                    *
  318. * Name         : translationChange                                   *
  319. *                                                                    *
  320. * Description  : Changes the translation in function of the operation*
  321. *                                                                    *
  322. * Arguments    : space        IN : Pointer to the space.             *
  323. *                 tvertex      IN : Vertex with coordinates.          *
  324. *                operation    IN : Operation to perform.             *
  325. *                                                                    *
  326. * Return Value : 0 if ok 1 if the operation is invalid.              *
  327. *                                                                    *
  328. * Comment      :                                                     *
  329. *                                                                    *
  330. \********************************************************************/
  331. static ULONG translationChange(TDspace *space,TDvectord tvertex, TDenum operation) {
  332.  
  333.     switch (operation) {
  334.         case TD_ADD :
  335.             space->ctm.m[3][0]+=tvertex.x;
  336.             space->ctm.m[3][1]+=tvertex.y;
  337.             space->ctm.m[3][2]+=tvertex.z;
  338.         break;
  339.         case TD_SUB :
  340.             space->ctm.m[3][0]-=tvertex.x;
  341.             space->ctm.m[3][1]-=tvertex.y;
  342.             space->ctm.m[3][2]-=tvertex.z;
  343.         break;
  344.         case TD_MUL :
  345.             space->ctm.m[3][0]*=tvertex.x;
  346.             space->ctm.m[3][1]*=tvertex.y;
  347.             space->ctm.m[3][2]*=tvertex.z;
  348.         break;
  349.         case TD_DIV :
  350.             if(tvertex.x!=0) space->ctm.m[3][0]/=tvertex.x;
  351.             else space->ctm.m[3][0]=0;
  352.             if(tvertex.y!=0) space->ctm.m[3][1]/=tvertex.y;
  353.             else space->ctm.m[3][1]=0;
  354.             if(tvertex.z!=0) space->ctm.m[3][2]/=tvertex.z;
  355.             else space->ctm.m[3][2]=0;
  356.         break;
  357.         case TD_SET :
  358.             space->ctm.m[3][0]=tvertex.x;
  359.             space->ctm.m[3][1]=tvertex.y;
  360.             space->ctm.m[3][2]=tvertex.z;
  361.         break;
  362.         case TD_RESET :
  363.             space->ctm.m[3][0]=0;
  364.             space->ctm.m[3][1]=0;
  365.             space->ctm.m[3][2]=0;
  366.             space->ctm.m[3][3]=1;
  367.         break;
  368.         default :
  369.             return(1);
  370.     }
  371.  
  372.     return(0);
  373. }
  374.  
  375. /********************************************************************\
  376. *                                                                    *
  377. * Name         : scaleChange                                         *
  378. *                                                                    *
  379. * Description  : Changes the scale in function of the operation      *
  380. *                                                                    *
  381. * Arguments    : space        IN : Pointer to the space.             *
  382. *                 svertex      IN : Vertex with coordinates.          *
  383. *                operation    IN : Operation to perform.             *
  384. *                                                                    *
  385. * Return Value : 0 if ok, 1 if the operation is not valid.           *
  386. *                                                                    *
  387. * Comment      :                                                     *
  388. *                                                                    *
  389. \********************************************************************/
  390. static ULONG scaleChange(TDspace *space,TDvectord svertex, TDenum operation) {
  391.  
  392.     switch (operation) {
  393.         case TD_ADD :
  394.             space->ctm.sx+=svertex.x;
  395.             space->ctm.sy+=svertex.y;
  396.             space->ctm.sz+=svertex.z;
  397.         break;
  398.         case TD_SUB :
  399.             space->ctm.sx-=svertex.x;
  400.             space->ctm.sy-=svertex.y;
  401.             space->ctm.sz-=svertex.z;
  402.         break;
  403.         case TD_MUL :
  404.             space->ctm.sx*=svertex.x;
  405.             space->ctm.sy*=svertex.y;
  406.             space->ctm.sz*=svertex.z;
  407.         break;
  408.         case TD_DIV :
  409.             if(svertex.x!=0) space->ctm.sx/=svertex.x;
  410.             else space->ctm.sx=0;
  411.             if(svertex.y!=0) space->ctm.sy/=svertex.y;
  412.             else space->ctm.sy=0;
  413.             if(svertex.z!=0) space->ctm.sz/=svertex.z;
  414.             else space->ctm.sz=0;
  415.         break;
  416.         case TD_SET :
  417.             space->ctm.sx=svertex.x;
  418.             space->ctm.sy=svertex.y;
  419.             space->ctm.sz=svertex.z;
  420.         break;
  421.         case TD_RESET :
  422.             space->ctm.sx=1;
  423.             space->ctm.sy=1;
  424.             space->ctm.sz=1;
  425.         break;
  426.         default :
  427.             return(1);
  428.     }
  429.  
  430.     return(0);
  431. }
  432.  
  433. /********************************************************************\
  434. *                                                                    *
  435. * Name         : rotationChange                                      *
  436. *                                                                    *
  437. * Description  : Changes the rotation in function of the operation   *
  438. *                                                                    *
  439. * Arguments    : space        IN : Pointer to the space.             *
  440. *                 rvertex      IN : Vertex with coordinates.          *
  441. *                operation    IN : Operation to perform.             *
  442. *                                                                    *
  443. * Return Value : 0 if ok, 1 if the operation is not valid.           *
  444. *                                                                    *
  445. * Comment      :                                                     *
  446. *                                                                    *
  447. \********************************************************************/
  448. static ULONG rotationChange(TDspace *space,TDvectord rvertex, TDenum operation) {
  449.     TDdouble    m1[3][3],m2[3][3];
  450.  
  451.     switch (operation) {
  452.         case TD_ADD :
  453.             space->ctm.rx+=rvertex.x;
  454.             space->ctm.ry+=rvertex.y;
  455.             space->ctm.rz+=rvertex.z;
  456.         break;
  457.         case TD_SUB :
  458.             space->ctm.rx-=rvertex.x;
  459.             space->ctm.ry-=rvertex.y;
  460.             space->ctm.rz-=rvertex.z;
  461.         break;
  462.         case TD_MUL :
  463.             space->ctm.rx*=rvertex.x;
  464.             space->ctm.ry*=rvertex.y;
  465.             space->ctm.rz*=rvertex.z;
  466.         break;
  467.         case TD_DIV :
  468.             if(rvertex.x!=0) space->ctm.rx/=rvertex.x;
  469.             else space->ctm.rx=0;
  470.             if(rvertex.y!=0) space->ctm.ry/=rvertex.y;
  471.             else space->ctm.ry=0;
  472.             if(rvertex.z!=0) space->ctm.rz/=rvertex.z;
  473.             else space->ctm.rz=0;
  474.         break;
  475.         case TD_SET :
  476.             space->ctm.rx=rvertex.x;
  477.             space->ctm.ry=rvertex.y;
  478.             space->ctm.rz=rvertex.z;
  479.         break;
  480.         case TD_RESET :
  481.             space->ctm.rx=0;
  482.             space->ctm.ry=0;
  483.             space->ctm.rz=0;
  484.         break;
  485.         default :
  486.             return(1);
  487.     }
  488.  
  489.     // If equal to 2*PI set to 0
  490.     if(space->ctm.rx==2*PI) space->ctm.rx=0;
  491.     if(space->ctm.ry==2*PI) space->ctm.ry=0;
  492.     if(space->ctm.rz==2*PI) space->ctm.rz=0;
  493.  
  494.     // Recalculating the CTM
  495.     m1[0][0]=1;
  496.     m1[1][0]=0;
  497.     m1[2][0]=0;
  498.     m1[0][1]=0;
  499.     m1[1][1]=1;
  500.     m1[2][1]=0;
  501.     m1[0][2]=0;
  502.     m1[1][2]=0;
  503.     m1[2][2]=1;
  504.  
  505.     m2[0][0]=cos(space->ctm.rz);
  506.     m2[1][0]=-sin(space->ctm.rz);
  507.     m2[2][0]=0;
  508.     m2[0][1]=sin(space->ctm.rz);
  509.     m2[1][1]=cos(space->ctm.rz);
  510.     m2[2][1]=0;
  511.     m2[0][2]=0;
  512.     m2[1][2]=0;
  513.     m2[2][2]=1;
  514.  
  515.     mulMatrix(m1,m2);
  516.  
  517.     m2[0][0]=cos(space->ctm.ry);
  518.     m2[1][0]=0;
  519.     m2[2][0]=sin(space->ctm.ry);
  520.     m2[0][1]=0;
  521.     m2[1][1]=1;
  522.     m2[2][1]=0;
  523.     m2[0][2]=-sin(space->ctm.ry);
  524.     m2[1][2]=0;
  525.     m2[2][2]=cos(space->ctm.ry);
  526.  
  527.     mulMatrix(m1,m2);
  528.  
  529.     m2[0][0]=1;
  530.     m2[1][0]=0;
  531.     m2[2][0]=0;
  532.     m2[0][1]=0;
  533.     m2[1][1]=cos(space->ctm.rx);
  534.     m2[2][1]=-sin(space->ctm.rx);
  535.     m2[0][2]=0;
  536.     m2[1][2]=sin(space->ctm.rx);
  537.     m2[2][2]=cos(space->ctm.rx);
  538.  
  539.     mulMatrix(m1,m2);
  540.  
  541.     space->ctm.m[0][0]=m1[0][0];
  542.     space->ctm.m[1][0]=m1[1][0];
  543.     space->ctm.m[2][0]=m1[2][0];
  544.     space->ctm.m[0][1]=m1[0][1];
  545.     space->ctm.m[1][1]=m1[1][1];
  546.     space->ctm.m[2][1]=m1[2][1];
  547.     space->ctm.m[0][2]=m1[0][2];
  548.     space->ctm.m[1][2]=m1[1][2];
  549.     space->ctm.m[2][2]=m1[2][2];
  550.  
  551.     return(0);
  552. }
  553.  
  554. /********************************************************************\
  555. *                                                                    *
  556. * Name         : getMatGroupNode                                     *
  557. *                                                                    *
  558. * Description  : Search the matgroup its node with its index, in     *
  559. *                the given mesh. If the index is not valid, NULL     *
  560. *                will be returned.                                   *
  561. *                                                                    *
  562. * Arguments    : mesh          IN : Pointer to the mesh.             *
  563. *                matgroupindex IN : Matgroup index.                  *
  564. *                                                                    *
  565. * Return Value : Pointer to the matgroup or NULL if not found.       *
  566. *                                                                    *
  567. * Comment      : The array indices are beginnning at 0, index at 1   *
  568. *                                                                    *
  569. \********************************************************************/
  570. static TDmatgroupnode *getMatGroupNode(TDpolymesh *mesh, ULONG matgroupindex) {
  571.     ULONG matgroupblock,matgroupnode;
  572.  
  573.     // if we have matgroups, and the index is between 1 and numberOfMatGroupss
  574.     if(mesh->matgroups.numberOfMatGroups==0) return(NULL);
  575.     if(matgroupindex<1 || matgroupindex>mesh->matgroups.numberOfMatGroups) return(NULL);
  576.  
  577.     // internal index is - 1
  578.     matgroupindex--;
  579.  
  580.     // compute the block and node and return the matgroup node
  581.     matgroupnode=matgroupindex%Ci_MATGROUPNODESINBLOCK;
  582.     matgroupblock=(matgroupindex-matgroupnode)/Ci_MATGROUPNODESINBLOCK;
  583.     return(mesh->matgroups.blocks[matgroupblock]->nodes[matgroupnode]);
  584. }
  585.  
  586. /********************************************************************\
  587. *                                                                    *
  588. * Name         : cleanPolyMesh                                       *
  589. *                                                                    *
  590. * Description  : If an error occurs while creating a new mesh, call  *
  591. *                this one to delete it.                              *
  592. *                                                                    *
  593. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  594. *                                                                    *
  595. * Comment      :                                                     *
  596. *                                                                    *
  597. \********************************************************************/
  598. static VOID cleanPolyMesh(TDpolymesh *mesh) {
  599.  
  600.     DeletePool(mesh->vertexpool);
  601.     DeletePool(mesh->vertexarraypool);
  602.     DeletePool(mesh->vertexblockspool);
  603.     DeletePool(mesh->polyverpool);
  604.     DeletePool(mesh->polypool);
  605.     DeletePool(mesh->polyarraypool);
  606.     DeletePool(mesh->polyblockspool);
  607.     DeletePool(mesh->matgroupblockspool);
  608.     FreeMem(mesh,sizeof(TDpolymesh));
  609. };
  610.  
  611. /********************************************************************\
  612. *                                                                    *
  613. * Name         : newPolyMesh                                         *
  614. *                                                                    *
  615. * Description  : Creates and initializes a new polymesh.             *
  616. *                                                                    *
  617. * Return Value : Handle of the new mesh or 0 if no more memory.      *
  618. *                                                                    *
  619. * Comment      :                                                     *
  620. *                                                                    *
  621. \********************************************************************/
  622. static ULONG newPolyMesh() {
  623.     TDpolymesh    *mesh=NULL;
  624.  
  625.     mesh = AllocMem(sizeof(TDpolymesh),MEMF_FAST);
  626.     if (mesh==NULL) return(0);
  627.  
  628.     // initialize the pool headers and other pointers
  629.     mesh->vertexpool=NULL;
  630.     mesh->vertexarraypool=NULL;
  631.     mesh->vertexblockspool=NULL;
  632.     mesh->polyverpool=NULL;
  633.     mesh->polypool=NULL;
  634.     mesh->polyarraypool=NULL;
  635.     mesh->polyblockspool=NULL;
  636.     mesh->matgroupblockspool=NULL;
  637.  
  638.     mesh->curpolyn=NULL;
  639.     mesh->curmatgroupn=NULL;
  640.  
  641.     // create a memory pool for the vertices of this this mesh
  642.     // ground size of a pool is to get 100 vertices
  643.     mesh->vertexpool=CreatePool(MEMF_FAST,100*sizeof(TDvectord),100*sizeof(TDvectord));
  644.     if(mesh->vertexpool==NULL) {
  645.         cleanPolyMesh(mesh);
  646.         return(0);
  647.     }
  648.  
  649.     // create a memory pool for the vertex arrays of this this mesh
  650.     // ground size of a pool is to get one array of vertices
  651.     mesh->vertexarraypool=CreatePool(MEMF_FAST,sizeof(TDvertexarray),sizeof(TDvertexarray));
  652.     if(mesh->vertexarraypool==NULL) {
  653.         cleanPolyMesh(mesh);
  654.         return(0);
  655.     }
  656.  
  657.     // create a memory pool for the vertex blocks of this this mesh
  658.     // ground size of a pool is to get one block of vertex arrays
  659.     mesh->vertexblockspool=CreatePool(MEMF_FAST,sizeof(TDvertexblock),sizeof(TDvertexblock));
  660.     if(mesh->vertexblockspool==NULL) {
  661.         cleanPolyMesh(mesh);
  662.         return(0);
  663.     }
  664.  
  665.     // create a memory pool for the polygon vertex array of this this mesh
  666.     // ground size of a pool is to get one vertex in the array
  667.     mesh->polyverpool=CreatePool(MEMF_FAST,sizeof(ULONG),sizeof(ULONG));
  668.     if(mesh->polyverpool==NULL) {
  669.         cleanPolyMesh(mesh);
  670.         return(0);
  671.     }
  672.  
  673.     // create a memory pool for the polygons of this this mesh
  674.     // ground size of a pool is to get 100 polygons
  675.     mesh->polypool=CreatePool(MEMF_FAST,100*sizeof(TDpolygonnode),100*sizeof(TDpolygonnode));
  676.     if(mesh->polypool==NULL) {
  677.         cleanPolyMesh(mesh);
  678.         return(0);
  679.     }
  680.  
  681.     // create a memory pool for the polygon arrays of this this mesh
  682.     // ground size of a pool is to get one array of polygons
  683.     mesh->polyarraypool=CreatePool(MEMF_FAST,sizeof(TDpolygonarray),sizeof(TDpolygonarray));
  684.     if(mesh->polyarraypool==NULL) {
  685.         cleanPolyMesh(mesh);
  686.         return(0);
  687.     }
  688.  
  689.     // create a memory pool for the polygon blocks of this this mesh
  690.     // ground size of a pool is to get one block of polygon arrays
  691.     mesh->polyblockspool=CreatePool(MEMF_FAST,sizeof(TDpolygonblock),sizeof(TDpolygonblock));
  692.     if(mesh->polyblockspool==NULL) {
  693.         cleanPolyMesh(mesh);
  694.         return(0);
  695.     }
  696.  
  697.     // create a memory pool for the matgroup block lists of this this mesh
  698.     // ground size of a pool is one block of matgroups
  699.     mesh->matgroupblockspool=CreatePool(MEMF_FAST,sizeof(TDmatgroupblock),sizeof(TDmatgroupblock));
  700.     if(mesh->matgroupblockspool==NULL) {
  701.         cleanPolyMesh(mesh);
  702.         return(0);
  703.     }
  704.  
  705.     mesh->bBox.left=0.0;
  706.     mesh->bBox.right=0.0;
  707.     mesh->bBox.front=0.0;
  708.     mesh->bBox.rear=0.0;
  709.     mesh->bBox.top=0.0;
  710.     mesh->bBox.bottom=0.0;
  711.     
  712.     mesh->vertices.numberOfVertices=0;
  713.         
  714.     mesh->matgroups.numberOfMatGroups=0;
  715.     mesh->matgroups.numberOfPolygons=0;
  716.  
  717.     return(ULONG)mesh;
  718. }
  719.  
  720. /********************************************************************\
  721. *                                                                    *
  722. * Name         : delPolyMesh                                         *
  723. *                                                                    *
  724. * Description  : Deletes a polymesh and sub components.              *
  725. *                                                                    *
  726. * Arguments    : mesh  IN : Pointer to the mesh.                     *
  727. *                                                                    *
  728. \********************************************************************/
  729. static VOID delPolyMesh(TDpolymesh *mesh) {
  730.     TDmatgroupnode    *matgroup;
  731.     ULONG        i;
  732.  
  733.     /*
  734.     ** Free the vertices
  735.     */
  736.     DeletePool(mesh->vertexpool);
  737.     DeletePool(mesh->vertexarraypool);
  738.     DeletePool(mesh->vertexblockspool);
  739.  
  740.     /*
  741.     ** Free the polygons
  742.     */
  743.     DeletePool(mesh->polyverpool);
  744.     DeletePool(mesh->polypool);
  745.     DeletePool(mesh->polyarraypool);
  746.     DeletePool(mesh->polyblockspool);
  747.  
  748.     /*
  749.     ** Free the matgroups and the nodeslist
  750.     */
  751.     for(i=1;i<=mesh->matgroups.numberOfMatGroups;i++) {
  752.         matgroup=getMatGroupNode(mesh,i);
  753.  
  754.         FreeMem(matgroup,sizeof(TDmatgroupnode));
  755.     }
  756.     DeletePool(mesh->matgroupblockspool);
  757.  
  758.     /*
  759.     ** Free the mesh itself
  760.     */
  761.     FreeMem(mesh,sizeof(TDpolymesh));
  762. }
  763.  
  764. /********************************************************************\
  765. *                                                                    *
  766. * Name         : addObjectNode                                       *
  767. *                                                                    *
  768. * Description  : Add a new object node to the space.                 *
  769. *                                                                    *
  770. * Arguments    : space  IN : Pointer to the space.                   *
  771. *                type   IN : Type of object.                         *
  772. *                                                                    *
  773. * Return Value : Index of the new object or 0 if no more memory.     *
  774. *                                                                    *
  775. * Comment      : The array indices are beginnning at 0, index at 1   *
  776. *                                                                    *
  777. \********************************************************************/
  778. static ULONG addObjectNode(TDspace *space,TDenum type) {
  779.     TDobjectnode        *object=NULL;
  780.     TDcube                *cube=NULL;
  781.     TDtexbinding        *texbind=NULL;
  782.     UBYTE                buffer[100];
  783.     ULONG                objectnode,objectblock,realobject;
  784.     
  785.     // check if we have still place for an object node
  786.     objectnode=(space->objects.numberOfObjects)%Ci_OBJECTNODESINBLOCK;
  787.     objectblock=((space->objects.numberOfObjects)-objectnode)/Ci_OBJECTNODESINBLOCK;
  788.  
  789.     // we are above our internal limit
  790.     if(objectblock>=Ci_OBJECTBLOCKS) return(0);
  791.  
  792.     // check if we have to allocate a new nodes list block
  793.     if(objectnode==0) {
  794.         space->objects.blocks[objectblock]=AllocPooled(space->objectblockspool,sizeof(TDobjectblock));
  795.         if(space->objects.blocks[objectblock]==NULL) return(0);
  796.     }
  797.  
  798.     object = AllocMem(sizeof(TDobjectnode),MEMF_FAST);
  799.     if (object==NULL) {
  800.         return(0);
  801.     }
  802.  
  803.     object->name=NULL;
  804.     sprintf(buffer,"tdMESH%ld",space->objects.numberOfObjects);
  805.     object->name = AllocVec(strlen(buffer)+1,MEMF_FAST);
  806.     if (object->name==NULL) {
  807.         FreeMem(object,sizeof(TDobjectnode));
  808.         return(0);
  809.     }
  810.     strcpy(object->name,buffer);
  811.  
  812.     // creating the mesh itself
  813.     switch(type) {
  814.         case TD_POLYMESH :
  815.             realobject=newPolyMesh();
  816.  
  817.             break;
  818.         case TD_CUBE :
  819.             cube=AllocMem(sizeof(TDcube),MEMF_FAST);
  820.             if(cube==NULL) {
  821.                 realobject=0;
  822.             } else {
  823.                 cube->size.x=0.0;cube->size.y=0,0;cube->size.z=0.0;
  824.                 realobject=(ULONG)cube;
  825.             }
  826.  
  827.             break;
  828.         case TD_TEXBINDING :
  829.             texbind=AllocMem(sizeof(TDtexbinding),MEMF_FAST);
  830.             if(texbind==NULL) {
  831.                 realobject=0;
  832.             } else {
  833.                 realobject=(ULONG)texbind;
  834.             }
  835.  
  836.             break;
  837.         default :
  838.             realobject=0;
  839.     }
  840.  
  841.     if(realobject==0) {
  842.         FreeVec(object->name);
  843.         FreeMem(object,sizeof(TDobjectnode));
  844.         return(0);
  845.     }
  846.  
  847.     object->type=type;
  848.     object->handle=realobject;
  849.  
  850.     object->s.x=1.0;
  851.     object->s.y=1.0;
  852.     object->s.z=1.0;
  853.  
  854.     object->r.x=0.0;
  855.     object->r.y=0.0;
  856.     object->r.z=0.0;
  857.  
  858.     object->o.x=0.0;
  859.     object->o.y=0.0;
  860.     object->o.z=0.0;
  861.     
  862.     // assign the node to the nodes list
  863.     space->objects.blocks[objectblock]->nodes[objectnode]=object;
  864.  
  865.     // last increment the numberOfObjects counter
  866.     space->objects.numberOfObjects++;
  867.  
  868.     return(space->objects.numberOfObjects);
  869. }
  870.  
  871. /********************************************************************\
  872. *                                                                    *
  873. * Name         : getObjectNode                                       *
  874. *                                                                    *
  875. * Description  : Search the object its node with its index, in       *
  876. *                the given space. If the index is not valid, NULL    *
  877. *                will be returned.                                   *
  878. *                                                                    *
  879. * Arguments    : space          IN : Pointer to the space            *
  880. *                objectindex    IN : Object index                    *
  881. *                                                                    *
  882. * Return Value : Pointer to the object or NULL if not found.         *
  883. *                                                                    *
  884. * Comment      : The array indices are beginnning at 0, index at 1   *
  885. *                                                                    *
  886. \********************************************************************/
  887. static TDobjectnode *getObjectNode(TDspace *space, ULONG objectindex) {
  888.     ULONG objectblock,objectnode;
  889.  
  890.     // if we have objects, and the index is between 1 and numberOfObjects
  891.     if(space->objects.numberOfObjects==0) return(NULL);
  892.     if(objectindex<1 || objectindex>space->objects.numberOfObjects) return(NULL);
  893.  
  894.     // internal index is index - 1
  895.     objectindex--;
  896.  
  897.     // compute the block and node and return the object node
  898.     objectnode=objectindex%Ci_OBJECTNODESINBLOCK;
  899.     objectblock=(objectindex-objectnode)/Ci_OBJECTNODESINBLOCK;
  900.     return(space->objects.blocks[objectblock]->nodes[objectnode]);
  901. }
  902.  
  903. /********************************************************************\
  904. *                                                                    *
  905. * Name         : vector2CTM                                          *
  906. *                                                                    *
  907. * Description  : Transforms a vector according the CTM.              *
  908. *                                                                    *
  909. * Arguments    : ctm      IN : CTM to use.                           *
  910. *                vector   IN : Vector to transform.                  *
  911. *                                                                    *
  912. * Comment      : This function is for time uncritical use only !     *
  913. *                                                                    *
  914. \********************************************************************/
  915. static VOID vector2CTM(TDctm ctm, TDvectord *vector) {
  916.     TDvectord rvector;
  917.  
  918.     rvector=(*vector);
  919.  
  920.     // Scaling
  921.     rvector.x*=ctm.sx,rvector.y*=ctm.sy,rvector.z*=ctm.sz;
  922.  
  923.     //Rotation and translation
  924.     vector->x=ctm.m[0][0]*rvector.x+ctm.m[1][0]*rvector.y+ctm.m[2][0]*rvector.z+ctm.m[3][0]; 
  925.     vector->y=ctm.m[0][1]*rvector.x+ctm.m[1][1]*rvector.y+ctm.m[2][1]*rvector.z+ctm.m[3][1]; 
  926.     vector->z=ctm.m[0][2]*rvector.x+ctm.m[1][2]*rvector.y+ctm.m[2][2]*rvector.z+ctm.m[3][2]; 
  927. }
  928.  
  929. /********************************************************************\
  930. *                                                                    *
  931. * Name         : addMatGroupNode                                     *
  932. *                                                                    *
  933. * Description  : Add a new matgroup node to the polymesh.            *
  934. *                                                                    *
  935. * Arguments    : mesh      IN : Pointer to the polymesh.             *
  936. *                matnode   IN : Node of the material.                *
  937. *                                                                    *
  938. * Return Value : Node of the new matgroup or NULL if no more memory. *
  939. *                                                                    *
  940. * Comment      : The array indices are beginnning at 0, index at 1   *
  941. *                                                                    *
  942. \********************************************************************/
  943. static TDmatgroupnode *addMatGroupNode(TDpolymesh *mesh,TDmaterialnode *matnode) {
  944.     static TDmatgroupnode        *matgroup=NULL;
  945.     ULONG    matgroupnode,matgroupblock;
  946.     
  947.     // check if we have still place for a matgroup node
  948.     matgroupnode=(mesh->matgroups.numberOfMatGroups)%Ci_MATGROUPNODESINBLOCK;
  949.     matgroupblock=((mesh->matgroups.numberOfMatGroups)-matgroupnode)/Ci_MATGROUPNODESINBLOCK;
  950.  
  951.     if(matgroupblock>=Ci_MATGROUPBLOCKS) return(NULL);
  952.  
  953.     // check if we have to allocate a new nodes list block
  954.     if(matgroupnode==0) {
  955.         mesh->matgroups.blocks[matgroupblock]=AllocPooled(mesh->matgroupblockspool,sizeof(TDmatgroupblock));
  956.         if(mesh->matgroups.blocks[matgroupblock]==NULL) return(NULL);
  957.     }
  958.  
  959.     matgroup = AllocMem(sizeof(TDmatgroupnode),MEMF_FAST);
  960.     if (matgroup==NULL) {
  961.         return(NULL);
  962.     }
  963.  
  964.     matgroup->polygons.numberOfPolygons=0;
  965.     matgroup->polygons.numberOfVertices=0;
  966.  
  967.     matgroup->materialnode=NULL;
  968.     matgroup->texbindex=0;
  969.  
  970.     switch(matnode->type) {
  971.         case TD_SURFACE :
  972.             matgroup->materialnode=matnode;
  973.             break;
  974.     }
  975.  
  976.     // assign the node to the nodes list
  977.     mesh->matgroups.blocks[matgroupblock]->nodes[matgroupnode]=matgroup;
  978.  
  979.     // last increment the numberOfMatGroups counter
  980.     mesh->matgroups.numberOfMatGroups++;
  981.  
  982.     return(matgroup);
  983. }
  984.  
  985. /********************************************************************\
  986. *                                                                    *
  987. * Name         : addPolygon                                          *
  988. *                                                                    *
  989. * Description  : Adds the polygon to the matgroup of the mesh,       *
  990. *                The size of the vertex array may be set.            *
  991. *                                                                    *
  992. * Arguments    : mesh     IN : Pointer to the mesh.                  *
  993. *                matgroup IN : Pointer to the matgroup.              *
  994. *                 size     IN : Initial size of the polygon.          *
  995. *                                                                    *
  996. * Return Value : Pointer to the polygon node or NULL if no memory.   *
  997. *                                                                    *
  998. * Comment      : The array indices are beginnning at 0, index at 1   *
  999. *                                                                    *
  1000. \********************************************************************/
  1001. static TDpolygonnode *addPolygon(TDpolymesh *mesh,TDmatgroupnode *matgroup,ULONG size) {
  1002.  
  1003.     TDpolygonnode        *poly=NULL;
  1004.     ULONG                polyparray,polybarray,polyblock;
  1005.  
  1006.     // check if we have still place for a polygon node
  1007.     polyparray=(matgroup->polygons.numberOfPolygons)%Ci_POLYARRAY;
  1008.     polybarray=(((matgroup->polygons.numberOfPolygons)-polyparray)/Ci_POLYARRAY)%Ci_POLYARRAYINBLOCK;
  1009.     polyblock=(polybarray*Ci_POLYARRAYINBLOCK+polyparray)/(Ci_POLYARRAY*Ci_POLYARRAYINBLOCK);
  1010.  
  1011.     if(polyblock>=Ci_POLYBLOCKS) return(NULL);
  1012.  
  1013.     // check if we have to allocate a new array of polygon arrays
  1014.     if(polybarray==0 && polyparray==0) {
  1015.         matgroup->polygons.blocks[polyblock]=AllocPooled(mesh->polyblockspool,sizeof(TDpolygonblock));
  1016.         if(matgroup->polygons.blocks[polyblock]==NULL) return(NULL);
  1017.     }
  1018.  
  1019.     // check if we have to allocate a new array of polygons
  1020.     if(polyparray==0) {
  1021.         matgroup->polygons.blocks[polyblock]->barray[polybarray]=AllocPooled(mesh->polyarraypool,sizeof(TDpolygonarray));
  1022.         if(matgroup->polygons.blocks[polyblock]->barray[polybarray]==NULL) return(NULL);
  1023.     }
  1024.  
  1025.     // make a new polygon node
  1026.     poly = AllocPooled(mesh->polypool,sizeof(TDpolygonnode));
  1027.     if (poly==NULL) return(NULL);
  1028.  
  1029.     poly->numberOfVertices=0;
  1030.  
  1031.     // make a new polygon vertex array node
  1032.     poly->varray = AllocPooled(mesh->polyverpool,size*sizeof(ULONG));
  1033.     if (poly->varray==NULL) return(NULL);
  1034.  
  1035.     // assign the polygon node to the polygon array list
  1036.     matgroup->polygons.blocks[polyblock]->barray[polybarray]->parray[polyparray]=poly;
  1037.  
  1038.     // last increment the numberOfPolygons counters
  1039.     mesh->matgroups.numberOfPolygons++;
  1040.     matgroup->polygons.numberOfPolygons++;
  1041.  
  1042.     return(poly);
  1043. }
  1044.  
  1045. /********************************************************************\
  1046. *                                                                    *
  1047. * Name         : getPolygonNode                                      *
  1048. *                                                                    *
  1049. * Description  : Search the polygon with its index, in the given     *
  1050. *                matgroup. If the index is not valid, NULL will be   *
  1051. *                returned.                                           *
  1052. *                                                                    *
  1053. * Arguments    : matgroup     IN : Pointer to the matgroup.          *
  1054. *                polyindex    IN : Polygon index.                    *
  1055. *                                                                    *
  1056. * Return Value : Pointer to the polygon or NULL if not found.        *
  1057. *                                                                    *
  1058. * Comment      : The array indices are beginnning at 0, index at 1   *
  1059. *                                                                    *
  1060. \********************************************************************/
  1061. static TDpolygonnode *getPolygonNode(TDmatgroupnode *matgroup, ULONG polyindex) {
  1062.     ULONG    polyparray,polybarray,polyblock;
  1063.  
  1064.     // if we have polygons, and the index is between 1 and numberOfPolygons
  1065.     if(matgroup->polygons.numberOfPolygons==0) return(NULL);
  1066.     if(polyindex<1 || polyindex>matgroup->polygons.numberOfPolygons) return(NULL);
  1067.  
  1068.     // internal index is - 1
  1069.     polyindex--;
  1070.  
  1071.     // compute the block, arraylist and array place and return the polygon
  1072.     polyparray=(polyindex)%Ci_POLYARRAY;
  1073.     polybarray=((polyindex-polyparray)/Ci_POLYARRAY)%Ci_POLYARRAYINBLOCK;
  1074.     polyblock=(polybarray*Ci_POLYARRAYINBLOCK+polyparray)/(Ci_POLYARRAY*Ci_POLYARRAYINBLOCK);
  1075.  
  1076.     return(matgroup->polygons.blocks[polyblock]->barray[polybarray]->parray[polyparray]);
  1077. }
  1078.  
  1079. /********************************************************************\
  1080. *                                                                    *
  1081. * Name         : addVertex                                           *
  1082. *                                                                    *
  1083. * Description  : Adds the vertex to the mesh, And returns the index  *
  1084. *                to it.                                              *
  1085. *                The vertex will be transformed according the CTM    *
  1086. *                                                                    *
  1087. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  1088. *                ctm    IN : The current transformation matrix.      *
  1089. *                vertex IN : The vertex to add.                      *
  1090. *                                                                    *
  1091. * Return Value : Index of the vertex. Or 0 if no more memory.        *
  1092. *                                                                    *
  1093. * Comment      : The array indices are beginnning at 0, index at 1   *
  1094. *                                                                    *
  1095. \********************************************************************/
  1096. static ULONG addVertex(TDpolymesh *mesh,TDctm ctm,TDvectord vertex) {
  1097.  
  1098.     TDvectord        rvertex,*ver=NULL;
  1099.     ULONG            vervarray,verbarray,verblock;
  1100.  
  1101.     // check if we have still place for a vertex node
  1102.     vervarray=(mesh->vertices.numberOfVertices)%Ci_VERTEXARRAY;
  1103.     verbarray=(((mesh->vertices.numberOfVertices)-vervarray)/Ci_VERTEXARRAY)%Ci_VERTEXARRAYINBLOCK;
  1104.     verblock=(verbarray*Ci_VERTEXARRAYINBLOCK+vervarray)/(Ci_VERTEXARRAY*Ci_VERTEXARRAYINBLOCK);
  1105.  
  1106.     if(verblock>=Ci_VERTEXBLOCKS) return(0);
  1107.  
  1108.     // check if we have to allocate a new array of vertex arrays
  1109.     if(verbarray==0 && vervarray==0) {
  1110.         mesh->vertices.blocks[verblock]=AllocPooled(mesh->vertexblockspool,sizeof(TDvertexblock));
  1111.         if(mesh->vertices.blocks[verblock]==NULL) return(0);
  1112.     }
  1113.  
  1114.     // check if we have to allocate a new array of vertices
  1115.     if(vervarray==0) {
  1116.         mesh->vertices.blocks[verblock]->barray[verbarray]=AllocPooled(mesh->vertexarraypool,sizeof(TDvertexarray));
  1117.         if(mesh->vertices.blocks[verblock]->barray[verbarray]==NULL) return(0);
  1118.     }
  1119.  
  1120.     // Transforming the the vertex according the CTM
  1121.  
  1122.     // Scaling
  1123.     vertex.x*=ctm.sx,vertex.y*=ctm.sy,vertex.z*=ctm.sz;
  1124.  
  1125.     //Rotation and translation
  1126.     rvertex.x=ctm.m[0][0]*vertex.x+ctm.m[1][0]*vertex.y+ctm.m[2][0]*vertex.z+ctm.m[3][0]; 
  1127.     rvertex.y=ctm.m[0][1]*vertex.x+ctm.m[1][1]*vertex.y+ctm.m[2][1]*vertex.z+ctm.m[3][1]; 
  1128.     rvertex.z=ctm.m[0][2]*vertex.x+ctm.m[1][2]*vertex.y+ctm.m[2][2]*vertex.z+ctm.m[3][2]; 
  1129.  
  1130.     // make a copy of the vertex
  1131.     ver = AllocPooled(mesh->vertexpool,sizeof(TDvectord));
  1132.     if (ver==NULL) return(0);
  1133.     
  1134.     (*ver)=rvertex;
  1135.  
  1136.     // assign the vertex copy to the vertex array list
  1137.     mesh->vertices.blocks[verblock]->barray[verbarray]->varray[vervarray]=ver;
  1138.  
  1139.     ver=mesh->vertices.blocks[verblock]->barray[verbarray]->varray[vervarray];
  1140.  
  1141.     // Recalculate the bounding box
  1142.     if(rvertex.x<mesh->bBox.left)   mesh->bBox.left=rvertex.x;
  1143.     if(rvertex.x>mesh->bBox.right)  mesh->bBox.right=rvertex.x;
  1144.     if(rvertex.y<mesh->bBox.rear)   mesh->bBox.rear=rvertex.y;
  1145.     if(rvertex.y>mesh->bBox.front)  mesh->bBox.front=rvertex.y;
  1146.     if(rvertex.z<mesh->bBox.bottom) mesh->bBox.bottom=rvertex.z;
  1147.     if(rvertex.z>mesh->bBox.top)    mesh->bBox.top=rvertex.z;
  1148.  
  1149.     // last increment the numberOfVertices counter
  1150.     mesh->vertices.numberOfVertices++;
  1151.  
  1152.     return(mesh->vertices.numberOfVertices);
  1153. }
  1154.  
  1155. /********************************************************************\
  1156. *                                                                    *
  1157. * Name         : getVertex                                           *
  1158. *                                                                    *
  1159. * Description  : Search the vertex with its index, in the given      *
  1160. *                mesh. If the index is not valid, NULL will be       *
  1161. *                returned.                                           *
  1162. *                                                                    *
  1163. * Arguments    : mesh           IN : Pointer to the mesh.            *
  1164. *                vertexindex    IN : Vertex index                    *
  1165. *                                                                    *
  1166. * Return Value : Pointer to the vertex or NULL if not found.         *
  1167. *                                                                    *
  1168. * Comment      : The array indices are beginnning at 0, index at 1   *
  1169. *                                                                    *
  1170. \********************************************************************/
  1171. static TDvectord *getVertex(TDpolymesh *mesh, ULONG vertexindex) {
  1172.     ULONG    vervarray,verbarray,verblock;
  1173.  
  1174.     // if we have vertices, and the index is between 1 and numberOfVertices
  1175.     if(mesh->vertices.numberOfVertices==0) return(NULL);
  1176.     if(vertexindex<1 || vertexindex>mesh->vertices.numberOfVertices) return(NULL);
  1177.  
  1178.     // internal index is - 1
  1179.     vertexindex--;
  1180.  
  1181.     // compute the block, arraylist and array place and return the vertex
  1182.     vervarray=(vertexindex)%Ci_VERTEXARRAY;
  1183.     verbarray=((vertexindex-vervarray)/Ci_VERTEXARRAY)%Ci_VERTEXARRAYINBLOCK;
  1184.     verblock=(verbarray*Ci_VERTEXARRAYINBLOCK+vervarray)/(Ci_VERTEXARRAY*Ci_VERTEXARRAYINBLOCK);
  1185.  
  1186.     return(mesh->vertices.blocks[verblock]->barray[verbarray]->varray[vervarray]);
  1187. }
  1188.  
  1189. /********************************************************************\
  1190. *                                                                    *
  1191. * Name         : assignVertex                                        *
  1192. *                                                                    *
  1193. * Description  : Assigns a vertex to a polygon node. The array of the*
  1194. *                node will be expanded if necessary.                 *
  1195. *                Assumed that the polygon has a minimum sized array  *
  1196. *                of Ci_POLYVERARRAYINIT.                             *
  1197. *                                                                    *
  1198. * Arguments    : mesh         IN : Pointer to the mesh.              *
  1199. *                 matgroup     IN : Pointer to the matgroup.          *
  1200. *                poly         IN : Pointer to the polygon.           *
  1201. *                 vertexindex  IN : Index to the vertex to assign.    *
  1202. *                                                                    *
  1203. * Return Value : 0 if no memory or the polygons count of vertices.   *
  1204. *                                                                    *
  1205. * Comment      : The array indices are beginnning at 0, index at 1   *
  1206. *                                                                    *
  1207. \********************************************************************/
  1208. static ULONG assignVertex(TDpolymesh *mesh,TDmatgroupnode *matgroup,
  1209.                             TDpolygonnode *poly,ULONG vertexindex) {
  1210.  
  1211.     ULONG    *varray;
  1212.     ULONG    nof;
  1213.  
  1214.     nof=poly->numberOfVertices;
  1215.  
  1216.     // check if we have to expand the vertex array
  1217.     if(nof<Ci_POLYVERARRAYINIT) {
  1218.         poly->varray[nof]=vertexindex;
  1219.     } else {
  1220.         // make a new polygon vertex array
  1221.         varray = AllocPooled(mesh->polyverpool,(nof+1)*sizeof(ULONG));
  1222.         if(varray==NULL) return(0);
  1223.  
  1224.         // copy the old array into the new one
  1225.         CopyMem(poly->varray,varray,nof*sizeof(ULONG));
  1226.  
  1227.         // free the old one
  1228.         FreePooled(mesh->polyverpool,poly->varray,nof*sizeof(ULONG));
  1229.  
  1230.         // assign the new array to the polygon
  1231.         poly->varray=varray;
  1232.  
  1233.         // assign the new vertex index
  1234.         poly->varray[nof]=vertexindex;
  1235.     }
  1236.  
  1237.     // last increment the numberOfVertices counters
  1238.     matgroup->polygons.numberOfVertices++;
  1239.     poly->numberOfVertices++;
  1240.  
  1241.     return(poly->numberOfVertices);
  1242. }
  1243.  
  1244.  
  1245.  
  1246.  
  1247.  
  1248.  
  1249.  
  1250.  
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  
  1258.  
  1259.  
  1260.  
  1261.  
  1262.  
  1263.  
  1264.  
  1265.  
  1266.  
  1267.  
  1268.  
  1269.  
  1270. /********************************************************************\
  1271. *                                                                    *
  1272. * Name         : setCameraLight                                      *
  1273. *                                                                    *
  1274. * Description  : Sets the default position of the camera and the     *
  1275. *                light and the camera its view point and the color   *
  1276. *                of the light source.                                *
  1277. *                                                                    *
  1278. * Arguments    : mesh      IN/OUT : Pointer to the mesh.             *
  1279. *                                                                    *
  1280. * Comment      :                                                     *
  1281. *                                                                    *
  1282. \********************************************************************/
  1283. static VOID setCameraLight(TTDOMesh *mesh) {
  1284.     TTDOVertexd ver1;
  1285.         
  1286.     if (mesh==NULL) return;
  1287.  
  1288.     /* camera its look at position */
  1289.     mesh->camera.lookat.x = (mesh->bBox.left + mesh->bBox.right) / 2;
  1290.     mesh->camera.lookat.y = (mesh->bBox.front + mesh->bBox.rear) / 2;
  1291.     mesh->camera.lookat.z = (mesh->bBox.top + mesh->bBox.bottom) / 2;
  1292.     
  1293.     /* direction vector */
  1294.     ver1.x = mesh->bBox.right - mesh->camera.lookat.x;
  1295.     ver1.y = mesh->bBox.front - mesh->camera.lookat.y;
  1296.     ver1.z = mesh->bBox.top - mesh->camera.lookat.z;
  1297.     
  1298.     ver1.x*=2.5;
  1299.     ver1.y*=2.5;    
  1300.     ver1.z*=2.5;
  1301.     
  1302.     /* camera its position */
  1303.     mesh->camera.position.x = ver1.x + mesh->camera.lookat.x;
  1304.     mesh->camera.position.y = ver1.y + mesh->camera.lookat.y;
  1305.     mesh->camera.position.z = ver1.z + mesh->camera.lookat.z;
  1306.  
  1307.     /* light source its position */
  1308.     mesh->light.position.x = ver1.x + mesh->camera.lookat.x;
  1309.     mesh->light.position.y = ver1.x + mesh->camera.lookat.x;
  1310.     mesh->light.position.z = ver1.x + mesh->camera.lookat.x;
  1311.     
  1312.     /* light source its color */
  1313.     mesh->light.color.r=255;
  1314.     mesh->light.color.g=255;
  1315.     mesh->light.color.b=255;
  1316. }
  1317.  
  1318.  
  1319.  
  1320.  
  1321.  
  1322.  
  1323.  
  1324.  
  1325.  
  1326.  
  1327.  
  1328.  
  1329.  
  1330.  
  1331.  
  1332.  
  1333. /********************************************************************\
  1334. *                                                                    *
  1335. * Name         : spaceClean                                          *
  1336. *                                                                    *
  1337. * Description  : If an error occurs while creating a new space, call *
  1338. *                this one to delete it.                              *
  1339. *                                                                    *
  1340. * Arguments    : space   IN : Pointer to the space.                  *
  1341. *                                                                    *
  1342. * Comment      :                                                     *
  1343. *                                                                    *
  1344. \********************************************************************/
  1345. static VOID spaceClean(TDspace *space) {
  1346.  
  1347.     DeletePool(space->objectblockspool);
  1348.     DeletePool(space->matblockspool);
  1349.     FreeVec(space->name);
  1350.     FreeMem(space,sizeof(TDspace));
  1351. };
  1352.  
  1353. /********************** Public functions ****************************/
  1354.  
  1355. /********************************************************************\
  1356. *                                                                    *
  1357. * Name         : initTDLibrary                                       *
  1358. *                                                                    *
  1359. * Description  : Initializes the TD library.                         *
  1360. *                                                                    *
  1361. * Return Value : 0 if all went well or 1 when no memory or file      *
  1362. *                accessing errors.                                   *
  1363. *                                                                    *
  1364. * Comment      :                                                     *
  1365. *                                                                    *
  1366. \********************************************************************/
  1367. ULONG initTDLibrary () {
  1368.     TD3dlibinfo *lib3dinfo=NULL;
  1369.  
  1370.     if((tdlibinfos=AllocMem(sizeof(TDlibraryinfo),MEMF_FAST))!=NULL) {
  1371.         if((tdlibinfos->lib3dinfos=AllocMem(sizeof(TD3dlibinfo *)*5,MEMF_FAST))!=NULL) {
  1372.  
  1373.             tdlibinfos->lib3dinfos[0]=AllocMem(sizeof(TD3dlibinfo),MEMF_FAST);
  1374.             lib3dinfo=tdlibinfos->lib3dinfos[0];
  1375.             lib3dinfo->library=AllocVec(sizeof(UBYTE)*strlen("dxf.library")+1,MEMF_FAST);
  1376.             strcpy(lib3dinfo->library,"dxf.library");
  1377.             lib3dinfo->name=AllocVec(sizeof(UBYTE)*strlen("Autocad DXF (TD)")+1,MEMF_FAST);
  1378.             strcpy(lib3dinfo->name,"Autocad DXF (TD)");
  1379.             lib3dinfo->ext=AllocVec(sizeof(UBYTE)*strlen("dxf")+1,MEMF_FAST);
  1380.             strcpy(lib3dinfo->ext,"dxf");
  1381.             lib3dinfo->supl=AllocVec(sizeof(TDenum)*3,MEMF_FAST);
  1382.             lib3dinfo->supl[0]=TD_OBJECT;
  1383.             lib3dinfo->supl[1]=TD_MATERIAL;
  1384.             lib3dinfo->supl[2]=TD_NOTHING;
  1385.             lib3dinfo->sups=AllocVec(sizeof(TDenum)*4,MEMF_FAST);
  1386.             lib3dinfo->sups[0]=TD_OBJECT;
  1387.             lib3dinfo->sups[1]=TD_MATERIAL;
  1388.             lib3dinfo->sups[2]=TD_SURFACE;
  1389.             lib3dinfo->sups[3]=TD_NOTHING;
  1390.  
  1391.             tdlibinfos->lib3dinfos[1]=AllocMem(sizeof(TD3dlibinfo),MEMF_FAST);
  1392.             lib3dinfo=tdlibinfos->lib3dinfos[1];
  1393.             lib3dinfo->library=AllocVec(sizeof(UBYTE)*strlen("rawa.library")+1,MEMF_FAST);
  1394.             strcpy(lib3dinfo->library,"rawa.library");
  1395.             lib3dinfo->name=AllocVec(sizeof(UBYTE)*strlen("RAW ASCII (TD)")+1,MEMF_FAST);
  1396.             strcpy(lib3dinfo->name,"RAW ASCII (TD)");
  1397.             lib3dinfo->ext=AllocVec(sizeof(UBYTE)*strlen("raw")+1,MEMF_FAST);
  1398.             strcpy(lib3dinfo->ext,"raw");
  1399.             lib3dinfo->supl=AllocVec(sizeof(TDenum)*2,MEMF_FAST);
  1400.             lib3dinfo->supl[0]=TD_OBJECT;
  1401.             lib3dinfo->supl[1]=TD_NOTHING;
  1402.             lib3dinfo->sups=NULL;
  1403.  
  1404.             tdlibinfos->lib3dinfos[2]=AllocMem(sizeof(TD3dlibinfo),MEMF_FAST);
  1405.             lib3dinfo=tdlibinfos->lib3dinfos[2];
  1406.             lib3dinfo->library=AllocVec(sizeof(UBYTE)*strlen("geoa.library")+1,MEMF_FAST);
  1407.             strcpy(lib3dinfo->library,"geoa.library");
  1408.             lib3dinfo->name=AllocVec(sizeof(UBYTE)*strlen("Videoscape ASCII (TD)")+1,MEMF_FAST);
  1409.             strcpy(lib3dinfo->name,"Videoscape ASCII (TD)");
  1410.             lib3dinfo->ext=AllocVec(sizeof(UBYTE)*strlen("geo")+1,MEMF_FAST);
  1411.             strcpy(lib3dinfo->ext,"geo");
  1412.             lib3dinfo->supl=AllocVec(sizeof(TDenum)*2,MEMF_FAST);
  1413.             lib3dinfo->supl[0]=TD_OBJECT;
  1414.             lib3dinfo->supl[1]=TD_NOTHING;
  1415.             lib3dinfo->sups=AllocVec(sizeof(TDenum)*2,MEMF_FAST);
  1416.             lib3dinfo->sups[0]=TD_OBJECT;
  1417.             lib3dinfo->sups[1]=TD_NOTHING;
  1418.  
  1419.             tdlibinfos->lib3dinfos[3]=AllocMem(sizeof(TD3dlibinfo),MEMF_FAST);
  1420.             lib3dinfo=tdlibinfos->lib3dinfos[3];
  1421.             lib3dinfo->library=AllocVec(sizeof(UBYTE)*strlen("vrml.library")+1,MEMF_FAST);
  1422.             strcpy(lib3dinfo->library,"vrml.library");
  1423.             lib3dinfo->name=AllocVec(sizeof(UBYTE)*strlen("VRML 1.0 (TD)")+1,MEMF_FAST);
  1424.             strcpy(lib3dinfo->name,"VRML 1.0 (TD)");
  1425.             lib3dinfo->ext=AllocVec(sizeof(UBYTE)*strlen("wrl")+1,MEMF_FAST);
  1426.             strcpy(lib3dinfo->ext,"wrl");
  1427.             lib3dinfo->supl=NULL;
  1428.             lib3dinfo->sups=AllocVec(sizeof(TDenum)*3,MEMF_FAST);
  1429.             lib3dinfo->sups[0]=TD_SPACE;
  1430.             lib3dinfo->sups[1]=TD_MATERIAL;
  1431.             lib3dinfo->sups[2]=TD_NOTHING;
  1432.  
  1433.             tdlibinfos->lib3dinfos[4]=NULL;
  1434.  
  1435.             return(0);
  1436.         }
  1437.     }
  1438.     
  1439.     return(1);
  1440. }
  1441.  
  1442. /********************************************************************\
  1443. *                                                                    *
  1444. * Name         : freeTDLibrary                                       *
  1445. *                                                                    *
  1446. * Description  : Free all memory allocated in initTDLibrary.         *
  1447. *                                                                    *
  1448. * Comment      :                                                     *
  1449. *                                                                    *
  1450. \********************************************************************/
  1451. VOID freeTDLibrary () {
  1452.     ULONG i=0;
  1453.     TD3dlibinfo *lib3dinfo=NULL;
  1454.  
  1455.     // free the library information structure
  1456.     if(tdlibinfos!=NULL) {
  1457.         // free the 3d library informations
  1458.         if(tdlibinfos->lib3dinfos!=NULL) {
  1459.             i=0;
  1460.             while(tdlibinfos->lib3dinfos[i]!=NULL) {
  1461.                 lib3dinfo=tdlibinfos->lib3dinfos[i];
  1462.  
  1463.                 FreeVec(lib3dinfo->library);
  1464.                 FreeVec(lib3dinfo->name);
  1465.                 FreeVec(lib3dinfo->ext);
  1466.  
  1467.                 if(lib3dinfo->supl!=NULL) {
  1468.                     FreeVec(lib3dinfo->supl);
  1469.                 }
  1470.  
  1471.                 if(lib3dinfo->sups!=NULL) {
  1472.                     FreeVec(lib3dinfo->sups);
  1473.                 }
  1474.  
  1475.                 FreeMem(lib3dinfo,sizeof(TD3dlibinfo));
  1476.                 i++;
  1477.             }
  1478.  
  1479.             i++;
  1480.             FreeMem(tdlibinfos->lib3dinfos,sizeof(TD3dlibinfo *)*i);
  1481.         }
  1482.  
  1483.         FreeMem(tdlibinfos,sizeof(TDlibraryinfo));
  1484.     }
  1485. }
  1486.  
  1487. /********************************************************************\
  1488. *                                                                    *
  1489. * Name         : fill3DFormatArrays.                                 *
  1490. *                                                                    *
  1491. * Description  : Fills up all 3D format arrays.                      *
  1492. *                                                                    *
  1493. * Arguments    : mesh         IN : Pointer to the mesh.              *
  1494. *                 rvertex      IN : Vertex with coordinates.          *
  1495. *                operation    IN : Operation to perform.             *
  1496. *                                                                    *
  1497. * Return Value : 0 if all went well or 1 when no memory or file      *
  1498. *                accessing errors.                                   *
  1499. *                                                                    *
  1500. * Comment      :                                                     *
  1501. *                                                                    *
  1502. \********************************************************************/
  1503. ULONG fill3DFormatArrays(){
  1504.  
  1505. /*
  1506. #include <dos/dos.h>
  1507. #include <dos/exall.h>
  1508. #include <dos/stdio.h>
  1509.  
  1510. #include <clib/exec_protos.h>
  1511. #include <clib/dos_protos.h>
  1512. #include <clib/alib_stdio_protos.h>
  1513.  
  1514. #define BUFFERSIZE 2048
  1515.  
  1516.  
  1517.     BPTR fl;
  1518.     struct ExAllControl *eac;
  1519.     struct ExAllData *ed,*p;
  1520.     LONG more,res2;
  1521.     ULONG n;
  1522.     UBYTE pattern[30];
  1523.  
  1524.  
  1525.     if((fl=Lock("libs:tdo/3dx",SHARED_LOCK)) != NULL) {
  1526.         if((eac=AllocDosObject(DOS_EXALLCONTROL, NULL)) != NULL) {
  1527.             if((ed=AllocMem(BUFFERSIZE,0))!=NULL) {
  1528.                 if(ParsePatternNoCase("#?.library",pattern,30)!=-1) {
  1529.                     eac->eac_LastKey=0;
  1530.                     eac->eac_MatchString=pattern;
  1531.                     eac->eac_MatchFunc=NULL;
  1532.  
  1533.                     do {
  1534.                         if((more=ExAll(fl,ed,BUFFERSIZE,ED_NAME,eac))!=DOSFALSE) {
  1535.                             for(p=ed,n=eac->eac_Entries;n!=0;p=p->ed_Next,--n) {
  1536.                                 printf("%s\n",p->ed_Name);
  1537.                             }
  1538.                         } else {
  1539.                             // fehler, buffer to small oder sonst was
  1540.                             ExAllEnd(fl,ed,BUFFERSIZE,ED_NAME,eac);
  1541.                             more=DOSFALSE;
  1542.                         }
  1543.                     } while(more!=DOSFALSE);
  1544.                     FreeMem(ed,BUFFERSIZE);
  1545.                 }
  1546.             }
  1547.             FreeDosObject(DOS_EXALLCONTROL,eac);
  1548.         }
  1549.         UnLock(fl);
  1550.     }
  1551. */
  1552. // !! nach namen format sortieren, alle arrays !
  1553.  
  1554.     BPTR fl;
  1555.     struct ExAllControl *eac;
  1556.     struct ExAllData *ed,*p;
  1557.     LONG more;
  1558.     ULONG n;
  1559.     UBYTE pattern[30];
  1560.     UBYTE libname[200];
  1561.  
  1562.     if((fl=Lock("libs:tdo/3x",SHARED_LOCK)) != NULL) {
  1563.         if((eac=AllocDosObject(DOS_EXALLCONTROL, NULL)) != NULL) {
  1564.             if((ed=AllocMem(EXALLBUFFERSIZE,0))!=NULL) {
  1565.                 if(ParsePatternNoCase("#?.library",pattern,30)!=-1) {
  1566.                     eac->eac_LastKey=0;
  1567.                     eac->eac_MatchString=pattern;
  1568.                     eac->eac_MatchFunc=NULL;
  1569.  
  1570.                     do {
  1571.                         if((more=ExAll(fl,ed,EXALLBUFFERSIZE,ED_NAME,eac))==DOSFALSE) {
  1572.                             for(p=ed,n=eac->eac_Entries;n!=0;p=p->ed_Next,--n) {
  1573.                                 printf("%s\n",p->ed_Name);
  1574.  
  1575.                                 // we skip corrupt libraries !
  1576.                                 sprintf(libname,"libs:tdo/3x/%s",p->ed_Name);
  1577.                                 if((x3Base=(APTR) OpenLibrary(libname,0))!=NULL) {
  1578. // lokales grosses array fuer init, dann copy nach c3... da ja zuerst alles lesen usw...
  1579.                                     printf("impl S %ld L %ld\n",tdo3XSave(0,NULL,NULL),tdo3XLoad(0,NULL,NULL,NULL));
  1580.  
  1581.                                     CloseLibrary((APTR)x3Base);
  1582.                                 }
  1583.                             }
  1584.                         } else {
  1585.                             // buffer to small or dos error
  1586.                             ExAllEnd(fl,ed,EXALLBUFFERSIZE,ED_NAME,eac);
  1587.                             more=DOSFALSE;
  1588.                         }
  1589.                     } while(more!=DOSFALSE);
  1590.                     FreeMem(ed,EXALLBUFFERSIZE);
  1591.                 }
  1592.             }
  1593.             FreeDosObject(DOS_EXALLCONTROL,eac);
  1594.         }
  1595.         UnLock(fl);
  1596.     }
  1597. /*
  1598.     c3dsLib=AllocVec(4*sizeof(STRPTR),MEMF_FAST);
  1599.     c3dsLib[0]=AllocVec(strlen("rawb.library")+1,MEMF_FAST);
  1600.     strcpy(c3dsLib[0],"rawb.library");
  1601.     c3dsLib[1]=AllocVec(strlen("geoa.library")+1,MEMF_FAST);
  1602.     strcpy(c3dsLib[1],"geoa.library");
  1603.     c3dsLib[2]=AllocVec(strlen("rawa.library")+1,MEMF_FAST);
  1604.     strcpy(c3dsLib[2],"rawa.library");
  1605.     c3dsLib[3]=NULL;
  1606.  
  1607.     c3dsNames=AllocVec(4*sizeof(STRPTR),MEMF_FAST);
  1608.     c3dsNames[0]=AllocVec(strlen("RAW binary")+1,MEMF_FAST);
  1609.     strcpy(c3dsNames[0],"RAW binary");
  1610.     c3dsNames[1]=AllocVec(strlen("Videoscape ASCII")+1,MEMF_FAST);
  1611.     strcpy(c3dsNames[1],"Videoscape ASCII");
  1612.     c3dsNames[2]=AllocVec(strlen("RAW ASCII")+1,MEMF_FAST);
  1613.     strcpy(c3dsNames[2],"RAW ASCII");
  1614.     c3dsNames[3]=NULL;
  1615.  
  1616.     c3dsExt=AllocVec(4*sizeof(STRPTR),MEMF_FAST);
  1617.     c3dsExt[0]=AllocVec(strlen("raw")+1,MEMF_FAST);
  1618.     strcpy(c3dsExt[0],"raw");
  1619.     c3dsExt[1]=AllocVec(strlen("geo")+1,MEMF_FAST);
  1620.     strcpy(c3dsExt[1],"geo");
  1621.     c3dsExt[2]=AllocVec(strlen("raw")+1,MEMF_FAST);
  1622.     strcpy(c3dsExt[2],"raw");
  1623.     c3dsExt[3]=NULL;
  1624.  
  1625.  
  1626.     c3dlLib=AllocVec(2*sizeof(STRPTR),MEMF_FAST);
  1627.     c3dlLib[0]=AllocVec(strlen("dxf.library")+1,MEMF_FAST);
  1628.     strcpy(c3dlLib[0],"dxf.library");
  1629.     c3dlLib[1]=AllocVec(strlen("ref4.library")+1,MEMF_FAST);
  1630.     strcpy(c3dlLib[1],"ref4.library");
  1631.     c3dlLib[2]=NULL;
  1632.  
  1633.     c3dlNames=AllocVec(2*sizeof(STRPTR),MEMF_FAST);
  1634.     c3dlNames[0]=AllocVec(strlen("Autodesk DXF")+1,MEMF_FAST);
  1635.     strcpy(c3dlNames[0],"Autodesk DXF");
  1636.     c3dlNames[1]=AllocVec(strlen("Reflections 4")+1,MEMF_FAST);
  1637.     strcpy(c3dlNames[1],"Reflections 4");
  1638.     c3dlNames[2]=NULL;
  1639. */
  1640.  
  1641.     return(0);
  1642. }
  1643.  
  1644. /********************************************************************\
  1645. *                                                                    *
  1646. * Name         : free3DFormatArrays.                                 *
  1647. *                                                                    *
  1648. * Description  : Free all 3D format arrays.                          *
  1649. *                                                                    *
  1650. * Comment      :                                                     *
  1651. *                                                                    *
  1652. \********************************************************************/
  1653. VOID free3DFormatArrays(){
  1654.     ULONG i;
  1655.  
  1656.     // 3D save libraries
  1657.     i=0;
  1658.     if(c3dsLib!=NULL) {
  1659.         while(c3dsLib[i]!=NULL) {
  1660.             FreeVec(c3dsLib[i++]);
  1661.         }
  1662.         FreeVec(c3dsLib);
  1663.         c3dsLib=NULL;
  1664.     }
  1665.  
  1666.     i=0;
  1667.     if(c3dsNames!=NULL) {
  1668.         while(c3dsNames[i]!=NULL) {
  1669.             FreeVec(c3dsNames[i++]);
  1670.         }
  1671.         FreeVec(c3dsNames);
  1672.         c3dsNames=NULL;
  1673.     }
  1674.  
  1675.     i=0;
  1676.     if(c3dsExt!=NULL) {
  1677.         while(c3dsExt[i]!=NULL) {
  1678.             FreeVec(c3dsExt[i++]);
  1679.         }
  1680.         FreeVec(c3dsExt);
  1681.         c3dsExt=NULL;
  1682.     }
  1683.  
  1684.     // 3d load libraries
  1685.     i=0;
  1686.     if(c3dlLib!=NULL) {
  1687.         while(c3dlLib[i]!=NULL) {
  1688.             FreeVec(c3dlLib[i++]);
  1689.         }
  1690.         FreeVec(c3dlLib);
  1691.         c3dlLib=NULL;
  1692.     }
  1693.  
  1694.     i=0;
  1695.     if(c3dlNames!=NULL) {
  1696.         while(c3dlNames[i]!=NULL) {
  1697.             FreeVec(c3dlNames[i++]);
  1698.         }
  1699.         FreeVec(c3dlNames);
  1700.         c3dlNames=NULL;
  1701.     }
  1702. }
  1703.  
  1704. /****** td.library/tdSpaceNew ******************************************
  1705. * 
  1706. *   NAME    
  1707. *     tdSpaceNew -- Creates a new space
  1708. * 
  1709. *   SYNOPSIS
  1710. *    spacehandle = tdSpaceNew( )
  1711. *              
  1712. *
  1713. *    ULONG tdSpaceNew
  1714. *         ( );
  1715. *
  1716. *   FUNCTION
  1717. *    Allocates the memory for a new space, initializes all its contents and
  1718. *    returns a handle to it.
  1719. *    The space becomes a default name and a default copyright.
  1720. *
  1721. *   You have to delete the space after usage with tdSpaceDelete().
  1722. *
  1723. *   INPUTS
  1724. * 
  1725. *   RESULT
  1726. *     spacehandle - A handle to the new space, or 0 in error case, which means
  1727. *                  that there is not enough memory available.
  1728. * 
  1729. *   EXAMPLE
  1730. *
  1731. *   NOTES
  1732. *
  1733. *   BUGS
  1734. * 
  1735. *   SEE ALSO
  1736. *     tdSpaceDelete()
  1737. *
  1738. *****************************************************************************
  1739. *
  1740. */
  1741. ULONG __saveds ASM tdSpaceNew() {
  1742.     TDspace     *space=NULL;
  1743.     UBYTE        buffer[20];
  1744.  
  1745.     space = AllocMem(sizeof(TDspace),MEMF_FAST);
  1746.     if (space==NULL) return(0);
  1747.  
  1748.     // initialize the pool headers and other pointers
  1749.     space->matblockspool=NULL;
  1750.     space->objectblockspool=NULL;
  1751.  
  1752.     space->name=NULL;
  1753.  
  1754.     // create a memory pool for the material block lists of this this space
  1755.     // ground size of a pool is one block of materials
  1756.     space->matblockspool=CreatePool(MEMF_FAST,sizeof(TDmaterialblock),sizeof(TDmaterialblock));
  1757.     if(space->matblockspool==NULL) {
  1758.         spaceClean(space);
  1759.         return(0);
  1760.     }
  1761.  
  1762.     // create a memory pool for the object block lists of this this space
  1763.     // ground size of a pool is one block of object
  1764.     space->objectblockspool=CreatePool(MEMF_FAST,sizeof(TDobjectblock),sizeof(TDobjectblock));
  1765.     if(space->objectblockspool==NULL) {
  1766.         spaceClean(space);
  1767.         return(0);
  1768.     }
  1769.  
  1770.     space->name=NULL;
  1771.     strcpy(buffer,"tdSPACE");
  1772.     space->name = AllocVec(strlen(buffer)+1,MEMF_FAST);
  1773.     if (space->name==NULL) {
  1774.         spaceClean(space);
  1775.         return(0);
  1776.     }
  1777.     strcpy(space->name,buffer);
  1778.     
  1779.     space->bBox.left=0.0;
  1780.     space->bBox.right=0.0;
  1781.     space->bBox.front=0.0;
  1782.     space->bBox.rear=0.0;
  1783.     space->bBox.top=0.0;
  1784.     space->bBox.bottom=0.0;
  1785.  
  1786.     space->curmatn=NULL;
  1787.     space->curobjn=NULL;
  1788.  
  1789.     space->objects.numberOfObjects=0;    
  1790.     space->materials.numberOfMaterials=0;
  1791.  
  1792.     space->ctm.sx=1,space->ctm.sy=1,space->ctm.sz=1;
  1793.     space->ctm.rx=0,space->ctm.ry=0,space->ctm.rz=0;
  1794.     space->ctm.m[0][0]=1,space->ctm.m[1][0]=0,space->ctm.m[2][0]=0,space->ctm.m[3][0]=0;
  1795.     space->ctm.m[0][1]=0,space->ctm.m[1][1]=1,space->ctm.m[2][1]=0,space->ctm.m[3][1]=0;
  1796.     space->ctm.m[0][2]=0,space->ctm.m[1][2]=0,space->ctm.m[2][2]=1,space->ctm.m[3][2]=0;
  1797.     space->ctm.m[0][3]=0,space->ctm.m[1][3]=0,space->ctm.m[2][3]=0,space->ctm.m[3][3]=1;
  1798.  
  1799.     return(ULONG)space;
  1800. }
  1801.  
  1802. /****** td.library/tdSpaceDelete ******************************************
  1803. * 
  1804. *   NAME    
  1805. *     tdSpaceDelete -- Delete a space which was created whith tdSpaceNew().
  1806. * 
  1807. *   SYNOPSIS
  1808. *    error = tdSpaceDelete( spacehandle )
  1809. *                           D1
  1810. *
  1811. *    TDerrors tdSpaceDelete
  1812. *         ( ULONG );
  1813. *
  1814. *   FUNCTION
  1815. *    Free the memory occupied by the space and all its components.
  1816. * 
  1817. *   INPUTS
  1818. *     spacehandle    - A valid handle of a space.
  1819. *    
  1820. *   RESULT
  1821. *     error - ER_NOERROR if all went well.
  1822. *            ER_NOSPACE if the handle is not valid.
  1823. *
  1824. *   EXAMPLE
  1825. * 
  1826. *   NOTES
  1827. *
  1828. *   BUGS
  1829. * 
  1830. *   SEE ALSO
  1831. *     tdSpaceNew()
  1832. * 
  1833. ******************************************************************************
  1834. *
  1835. */
  1836. TDerrors __saveds ASM tdSpaceDelete(register __d1 ULONG spacehandle) {
  1837.     TDspace                    *space=NULL;
  1838.     TDmaterialnode                *mat=NULL;
  1839.     TDobjectnode                *object=NULL;
  1840.     ULONG                        i;
  1841.  
  1842.     space=(TDspace *) spacehandle;
  1843.     if(space==NULL) return(ER_NOSPACE);
  1844.  
  1845.     /*
  1846.     ** Free the name string
  1847.     */
  1848.     FreeVec(space->name);
  1849.  
  1850.     /*
  1851.     ** Free the objects and the nodeslist
  1852.     */
  1853.     for(i=1;i<=space->objects.numberOfObjects;i++) {
  1854.         object=getObjectNode(space,i);
  1855.  
  1856.         FreeVec(object->name);
  1857.  
  1858.         switch(object->type) {
  1859.             case TD_CUBE :
  1860.                 FreeMem((TDcube *)object->handle,sizeof(TDcube));
  1861.                 break;
  1862.             case TD_POLYMESH :
  1863.                 delPolyMesh((TDpolymesh *)object->handle);
  1864.                 break;
  1865.             case TD_TEXBINDING :
  1866.                 FreeMem((TDtexbinding *)object->handle,sizeof(TDtexbinding));
  1867.                 break;
  1868.         }
  1869.  
  1870.         FreeMem(object,sizeof(TDobjectnode));
  1871.     }
  1872.     DeletePool(space->objectblockspool);
  1873.  
  1874.     /*
  1875.     ** Free the materials and the nodeslist
  1876.     */
  1877.     for(i=1;i<=space->materials.numberOfMaterials;i++) {
  1878.         mat=getMaterialNode(space,i);
  1879.  
  1880.         FreeVec(mat->name);
  1881.  
  1882.         switch(mat->type) {
  1883.             case TD_SURFACE :
  1884.                 FreeMem((TDsurface *)mat->handle,sizeof(TDsurface));
  1885.                 break;
  1886.             case TD_TEXTURE :
  1887.                 FreeMem((TDtexture *)mat->handle,sizeof(TDtexture));
  1888.                 break;
  1889.         }
  1890.  
  1891.         FreeMem(mat,sizeof(TDmaterialnode));
  1892.     }
  1893.     DeletePool(space->matblockspool);
  1894.  
  1895.     /*
  1896.     ** Free the space itself
  1897.     */
  1898.     FreeMem(space,sizeof(TDspace));
  1899.  
  1900.     return(ER_NOERROR);
  1901. }
  1902.  
  1903. /****** td.library/tdNameSet ******************************************
  1904. * 
  1905. *   NAME    
  1906. *     tdNameSet -- Set the name of component.
  1907. * 
  1908. *   SYNOPSIS
  1909. *    error = tdNameSet( spacehandle,type,index,name )
  1910. *                       D1          D2   D3    D4
  1911. *
  1912. *    TDerrors tdSpaceNameSet
  1913. *         ( ULONG,TDenum,ULONG,STRPTR );
  1914. *
  1915. *   FUNCTION
  1916. *    A copy of the passed string will be made and assigned to the
  1917. *    name string of the specified component of this space.
  1918. * 
  1919. *   INPUTS
  1920. *     spacehandle     - A valid handle of a space.
  1921. *    type            - The component its type.
  1922. *    index           - The component its index.
  1923. *    name            - String which contains the name.
  1924. *    
  1925. *   RESULT
  1926. *     error - ER_NOERROR  if all went well.
  1927. *            ER_NOSPACE  if the handle is not valid.
  1928. *            ER_NOTYPE   if the type is not valid.
  1929. *            ER_NOINDEX  if the index is not valid.
  1930. *             ER_NOMEMORY if there is not enough memory.
  1931. *
  1932. *   EXAMPLE
  1933. *    error = tdNameSet(spacehandle,TD_MATERIAL,3,"purple red");
  1934. *
  1935. *   NOTES
  1936. *    This function can be called as often as you need, which will
  1937. *    replace the old value.
  1938. *
  1939. *    When changing the name of a space, the index will not be
  1940. *    used, as the space is already known.
  1941. *
  1942. *    Not all formats support names, and the written length of the
  1943. *    string depends of the format too.
  1944. *
  1945. *   BUGS
  1946. * 
  1947. *   SEE ALSO
  1948. *     tdNameGet()
  1949. * 
  1950. ******************************************************************************
  1951. *
  1952. */
  1953. TDerrors __saveds ASM tdNameSet(register __d1 ULONG spacehandle,
  1954.                                 register __d2 TDenum type,
  1955.                                 register __d3 ULONG index,
  1956.                                 register __d4 STRPTR name ) {
  1957.  
  1958.     TDspace        *space=NULL;
  1959.     TDmaterialnode    *mat=NULL;
  1960.     TDobjectnode    *object=NULL;
  1961.   
  1962.     space=(TDspace *) spacehandle;
  1963.     if (space==NULL) return(ER_NOSPACE);
  1964.  
  1965.     // check which component has to be affected
  1966.     switch(type) {
  1967.         case TD_SPACE :
  1968.             // if the name was already set before, free it
  1969.             if(space->name) FreeVec(space->name);
  1970.             space->name=NULL;
  1971.  
  1972.             space->name=(STRPTR) AllocVec(strlen(name)+1,MEMF_FAST);
  1973.             if(space->name==NULL) return(ER_NOMEMORY);
  1974.   
  1975.             strcpy(space->name,name);
  1976.  
  1977.             break;
  1978.         case TD_MATERIAL :
  1979.             mat=getMaterialNode(space,index);
  1980.             if(mat==NULL) return(ER_NOINDEX);
  1981.  
  1982.             // If the name was already set before, free it
  1983.             if (mat->name) FreeVec(mat->name);
  1984.             mat->name=NULL;
  1985.     
  1986.             mat->name=(STRPTR) AllocVec(strlen(name)+1,MEMF_FAST);
  1987.             if(mat->name==NULL) return(ER_NOMEMORY);
  1988.   
  1989.             strcpy(mat->name,name);
  1990.  
  1991.             break;
  1992.         case TD_OBJECT :
  1993.             object=getObjectNode(space,index);
  1994.             if(object==NULL) return(ER_NOINDEX);
  1995.  
  1996.             // If the name was already set before, free it
  1997.             if (object->name) FreeVec(object->name);
  1998.             object->name=NULL;
  1999.     
  2000.             object->name=(STRPTR) AllocVec(strlen(name)+1,MEMF_FAST);
  2001.             if(object->name==NULL) return(ER_NOMEMORY);
  2002.   
  2003.             strcpy(object->name,name);
  2004.  
  2005.             break;
  2006.         default :
  2007.             return(ER_NOTYPE);
  2008.     }
  2009.  
  2010.     return(ER_NOERROR);
  2011. }
  2012.  
  2013. /****** td.library/tdNameGet ******************************************
  2014. * 
  2015. *   NAME    
  2016. *     tdNameGet -- Get the name of a component.
  2017. *
  2018. *   SYNOPSIS
  2019. *    error = tdNameGet( spacehandle,type,index,name )
  2020. *                       D1          D2   D3    D4
  2021. *
  2022. *    TDerrors tdNameGet
  2023. *         ( ULONG,TDenum,ULONG,STRPTR * );
  2024. *
  2025. *   FUNCTION
  2026. *    You will get a pointer to the name of the component.
  2027. *    This string is READ_ONLY and only valid as long the
  2028. *    as the component exists.
  2029. * 
  2030. *   INPUTS
  2031. *     spacehandle     - A valid handle of a space.
  2032. *    type            - The component its type.
  2033. *    index           - The component its index.
  2034. *    name            - Pointer to the name of the component.
  2035. *    
  2036. *   RESULT
  2037. *     error - ER_NOERROR  if all went well.
  2038. *            ER_NOSPACE  if the handle is not valid.
  2039. *            ER_NOTYPE   if the type is not valid.
  2040. *            ER_NOINDEX  if the index is not valid.
  2041. * 
  2042. *   EXAMPLE
  2043. *    error = tdNameGet(spacehandle,TD_SPACE,0,&mystring);
  2044. *
  2045. *   NOTES
  2046. *    When you will get the name of a space, the index will not be
  2047. *    used, as the space is already known.
  2048. *
  2049. *   BUGS
  2050. * 
  2051. *   SEE ALSO
  2052. *     tdNameSet()
  2053. * 
  2054. ******************************************************************************
  2055. *
  2056. */
  2057. TDerrors __saveds ASM tdNameGet(register __d1 ULONG spacehandle,
  2058.                                 register __d2 TDenum type,
  2059.                                 register __d3 ULONG index,
  2060.                                 register __d4 STRPTR *name ) {
  2061.  
  2062.     TDspace        *space=NULL;
  2063.     TDmaterialnode    *mat=NULL;
  2064.     TDobjectnode    *object=NULL;
  2065.  
  2066.     // initialize the name to NULL
  2067.     (*name)=NULL;
  2068.   
  2069.     space=(TDspace *) spacehandle;
  2070.     if (space==NULL) return(ER_NOSPACE);
  2071.  
  2072.     // check which component has to be affected
  2073.     switch(type) {
  2074.         case TD_SPACE :
  2075.             (*name)=space->name;
  2076.  
  2077.             break;
  2078.         case TD_MATERIAL :
  2079.             mat=getMaterialNode(space,index);
  2080.             if(mat==NULL) return(ER_NOINDEX);
  2081.  
  2082.             (*name)=mat->name;
  2083.  
  2084.             break;
  2085.         case TD_OBJECT :
  2086.             object=getObjectNode(space,index);
  2087.             if(object==NULL) return(ER_NOINDEX);
  2088.  
  2089.             (*name)=object->name;
  2090.  
  2091.             break;
  2092.         default :
  2093.             return(ER_NOTYPE);
  2094.     }
  2095.  
  2096.     return(ER_NOERROR);
  2097. }
  2098.  
  2099. /****** td.library/tdAdd ******************************************
  2100. * 
  2101. *   NAME    
  2102. *     tdAdd -- Add a new component to the space.
  2103. *
  2104. *   SYNOPSIS
  2105. *    error = tdAdd( spacehandle,type )
  2106. *                   D1          D2
  2107. *
  2108. *    TDerrors tdAdd
  2109. *         ( ULONG,TDenum );
  2110. *
  2111. *   FUNCTION
  2112. *    A new component will be created and added to the space.
  2113. *    You can access the component by its index which will
  2114. *    be the last of its type.
  2115. *
  2116. *    All properties will be set to default, strings too.
  2117. * 
  2118. *   INPUTS
  2119. *     spacehandle     - A valid handle of a space.
  2120. *    type            - The component its type.
  2121. *    
  2122. *   RESULT
  2123. *     error - ER_NOERROR  if all went well.
  2124. *            ER_NOSPACE  if the handle is not valid.
  2125. *            ER_NOTYPE   if the type is not valid.
  2126. *            ER_NOMEMORY if there is not enough memory. 
  2127. * 
  2128. *   EXAMPLE
  2129. *    error = tdAdd(spacehandle,TD_SURFACE);
  2130. *
  2131. *   NOTES
  2132. *
  2133. *   BUGS
  2134. * 
  2135. *   SEE ALSO
  2136. * 
  2137. ******************************************************************************
  2138. *
  2139. */
  2140. TDerrors __saveds ASM tdAdd(register __d1 ULONG spacehandle,register __d2 TDenum type) {
  2141.     TDspace        *space=NULL;
  2142.  
  2143.     space=(TDspace *) spacehandle;
  2144.     if (space==NULL) return(ER_NOSPACE);
  2145.  
  2146.     // check which component has to be affected
  2147.     switch(type) {
  2148.         case TD_SURFACE :
  2149.         case TD_TEXTURE :
  2150.             if(addMaterialNode(space,type)==0) return(ER_NOMEMORY);
  2151.  
  2152.             break;
  2153.         case TD_CUBE :
  2154.         case TD_POLYMESH :
  2155.         case TD_TEXBINDING :
  2156.             if(addObjectNode(space,type)==0) return(ER_NOMEMORY);
  2157.  
  2158.             break;
  2159.         default :
  2160.             return(ER_NOTYPE);
  2161.     }
  2162.  
  2163.     return(ER_NOERROR);
  2164. }
  2165.  
  2166. /****** td.library/tdNofGet ******************************************
  2167. * 
  2168. *   NAME    
  2169. *     tdNofGet -- Get the number of specific components in
  2170. *                the space or a child.
  2171. * 
  2172. *   SYNOPSIS
  2173. *    number = tdNofGet( spacehandle,type )
  2174. *                       D1          D2
  2175. *
  2176. *    ULONG tdNofGet
  2177. *         ( ULONG,TDenum )
  2178. *
  2179. *   FUNCTION
  2180. *    The current number of components of the specified type in the
  2181. *    space or a child will be returned.
  2182. * 
  2183. *   INPUTS
  2184. *     spacehandle     - A valid handle of a space.
  2185. *    type            - The component its type.
  2186. *    
  2187. *   RESULT
  2188. *     number - Number of components, 0 if none or no valid space or
  2189. *             component.
  2190. *
  2191. *   EXAMPLE
  2192. *    number = tdNofGet(spacehandle,TD_MATERIAL);
  2193. *
  2194. *   NOTES
  2195. *
  2196. *   BUGS
  2197. * 
  2198. *   SEE ALSO
  2199. * 
  2200. ******************************************************************************
  2201. *
  2202. */
  2203. ULONG __saveds ASM tdNofGet(register __d1 ULONG spacehandle,
  2204.                             register __d2 TDenum type) {
  2205.     TDspace        *space=NULL;
  2206.     TDmaterialnode    *mat=NULL;
  2207.     TDpolymesh        *polymesh=NULL;
  2208.  
  2209.     space=(TDspace *) spacehandle;
  2210.     if (space==NULL) return(0);
  2211.  
  2212.     // check which component has to be affected
  2213.     switch(type) {
  2214.         case TD_MATERIAL :
  2215.             return(space->materials.numberOfMaterials);
  2216.  
  2217.             break;
  2218.         case TD_OBJECT :
  2219.             return(space->objects.numberOfObjects);
  2220.  
  2221.             break;
  2222.         case TD_MATGROUP :
  2223.             if(space->curobjn==NULL) return(0);
  2224.             if(space->curobjn->type!=TD_POLYMESH) return(0);
  2225.  
  2226.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  2227.             return(polymesh->matgroups.numberOfMatGroups);
  2228.  
  2229.             break;
  2230.         case TD_POLYGON :
  2231.             if(space->curobjn==NULL) return(0);
  2232.             if(space->curobjn->type!=TD_POLYMESH) return(0);
  2233.  
  2234.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  2235.             if(polymesh->curmatgroupn==NULL) return(polymesh->matgroups.numberOfPolygons);
  2236.             else return(polymesh->curmatgroupn->polygons.numberOfPolygons);
  2237.             
  2238.             break;
  2239.         case TD_VERTEX :
  2240.             if(space->curobjn==NULL) return(0);
  2241.             if(space->curobjn->type!=TD_POLYMESH) return(0);
  2242.  
  2243.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  2244.             if(polymesh->curmatgroupn==NULL) return(polymesh->vertices.numberOfVertices);
  2245.             else if(polymesh->curpolyn==NULL) return(polymesh->curmatgroupn->polygons.numberOfVertices);
  2246.             else return(polymesh->curpolyn->numberOfVertices);
  2247.  
  2248.             break;
  2249.     }
  2250.  
  2251.     return(0);
  2252. }
  2253.  
  2254. /****** td.library/tdMaterialSetuba ******************************************
  2255. * 
  2256. *   NAME    
  2257. *     tdMaterialSetuba -- Set a parameter of the a material.
  2258. * 
  2259. *   SYNOPSIS
  2260. *    error = tdMaterialSetuba( spacehandle,type,index,array )
  2261. *                              D1          D2   D3    A0
  2262. *
  2263. *    TDerrors tdMaterialSetuba
  2264. *         ( ULONG,TDenum,ULONG,UBYTE * );
  2265. *
  2266. *   FUNCTION
  2267. *    The parameter of the material at index, will be changed.
  2268. *    Type specifies which parameter. The array its size is dependend
  2269. *    of the type.
  2270. * 
  2271. *   INPUTS
  2272. *     spacehandle     - A valid handle of a space.
  2273. *    type            - The parameter its type.
  2274. *    index           - The material its index.
  2275. *    array           - Array which contains the values.
  2276. *    
  2277. *   RESULT
  2278. *     error - ER_NOERROR  if all went well.
  2279. *            ER_NOSPACE  if the handle is not valid.
  2280. *            ER_NOTYPE   if the type is not valid.
  2281. *            ER_NOINDEX  if the index is not valid.
  2282. *
  2283. *   EXAMPLE
  2284. *    error = tdMaterialSetuba(spacehandle,TD_AMBIENT,3,red);
  2285. *
  2286. *   NOTES
  2287. *    If a value is out of range it will be set to its possible
  2288. *    maximum or minimum.
  2289. *
  2290. *   BUGS
  2291. * 
  2292. *   SEE ALSO
  2293. *     tdMaterialGet()
  2294. * 
  2295. ******************************************************************************
  2296. *
  2297. */
  2298. TDerrors __saveds ASM tdMaterialSetuba(register __d1 ULONG spacehandle,
  2299.                                         register __d2 TDenum type,
  2300.                                         register __d3 ULONG index,
  2301.                                         register __a0 UBYTE *array) {
  2302.     TDspace        *space=NULL;
  2303.     TDmaterialnode    *mat=NULL;
  2304.     TDsurface        *surf=NULL;
  2305.     TDtexture        *tex=NULL;
  2306.     UBYTE            *marray=NULL;
  2307.     TDcolorub        color;
  2308.  
  2309.     // make a copy of the array, because a0 is a scratch register
  2310.     marray = array;
  2311.  
  2312.     space=(TDspace *) spacehandle;
  2313.     if (space==NULL) return(ER_NOSPACE);
  2314.  
  2315.     mat=getMaterialNode(space,index);
  2316.     if(mat==NULL) return(ER_NOINDEX);
  2317.  
  2318.     // do this in function of the material type
  2319.     switch(mat->type) {
  2320.         case TD_SURFACE :
  2321.             surf=(TDsurface *)mat->handle;
  2322.  
  2323.             // check which parameter has to be changed
  2324.             switch(type) {
  2325.                 case TD_AMBIENT :
  2326.                     color.r=marray[0];
  2327.                     color.g=marray[1];
  2328.                     color.b=marray[2];
  2329.  
  2330.                     surf->ambientColor=color;
  2331.  
  2332.                     break;
  2333.                 case TD_DIFFUSE :
  2334.                     color.r=marray[0];
  2335.                     color.g=marray[1];
  2336.                     color.b=marray[2];
  2337.  
  2338.                     surf->diffuseColor=color;
  2339.  
  2340.                     break;
  2341.                 case TD_SHININESS :
  2342.                     surf->shininess=marray[0];
  2343.                     surf->shininess/=255;
  2344.  
  2345.                     break;
  2346.                 case TD_TRANSPARENCY :
  2347.                     surf->transparency=marray[0];
  2348.                     surf->transparency/=255;
  2349.  
  2350.                     break;
  2351.                 default :
  2352.                     return(ER_NOTYPE);
  2353.             }
  2354.             break;
  2355.  
  2356.         case TD_TEXTURE :
  2357.             tex=(TDtexture *)mat->handle;
  2358.             break;
  2359.  
  2360.     }
  2361.     return(ER_NOERROR);
  2362. }
  2363.  
  2364. /****** td.library/tdMaterialGetuba ******************************************
  2365. * 
  2366. *   NAME    
  2367. *     tdMaterialGetuba -- Get a parameter of the a material.
  2368. * 
  2369. *   SYNOPSIS
  2370. *    error = tdMaterialGetuba( spacehandle,type,index,array )
  2371. *                              D1          D2   D3    A0
  2372. *
  2373. *    TDerrors tdMaterialGetuba
  2374. *         ( ULONG,TDenum,ULONG,UBYTE * );
  2375. *
  2376. *   FUNCTION
  2377. *    The parameter of the material at index, will be returned.
  2378. *    Type specifies which parameter. The array its size is dependend
  2379. *    of the type.
  2380. * 
  2381. *   INPUTS
  2382. *     spacehandle     - A valid handle of a space.
  2383. *    type            - The parameter its type.
  2384. *    index           - The material its index.
  2385. *    array           - Pointer to a correct sized array, which
  2386. *                      will contain the values.
  2387. *    
  2388. *   RESULT
  2389. *     error - ER_NOERROR  if all went well.
  2390. *            ER_NOSPACE  if the handle is not valid.
  2391. *            ER_NOTYPE   if the type is not valid.
  2392. *            ER_NOINDEX  if the index is not valid.
  2393. *
  2394. *   EXAMPLE
  2395. *    error = tdMaterialGetuba(spacehandle,TD_AMBIENT,3,colorarray);
  2396. *
  2397. *   NOTES
  2398. *
  2399. *   BUGS
  2400. * 
  2401. *   SEE ALSO
  2402. *     tdMaterialSet()
  2403. * 
  2404. ******************************************************************************
  2405. *
  2406. */
  2407. TDerrors __saveds ASM tdMaterialGetuba(register __d1 ULONG spacehandle,
  2408.                                         register __d2 TDenum type,
  2409.                                         register __d3 ULONG index,
  2410.                                         register __a0 UBYTE *array) {
  2411.     TDspace        *space=NULL;
  2412.     TDmaterialnode    *mat=NULL;
  2413.     TDsurface        *surf=NULL;
  2414.     TDtexture        *tex=NULL;
  2415.     UBYTE            *marray=NULL;
  2416.  
  2417.     // make a copy of the array, because a0 is a scratch register
  2418.     marray = array;
  2419.  
  2420.     space=(TDspace *) spacehandle;
  2421.     if (space==NULL) return(ER_NOSPACE);
  2422.  
  2423.     mat=getMaterialNode(space,index);
  2424.     if(mat==NULL) return(ER_NOINDEX);
  2425.  
  2426.     // do this in function of the material type
  2427.     switch(mat->type) {
  2428.         case TD_SURFACE :
  2429.             surf=(TDsurface *)mat->handle;
  2430.  
  2431.             // check which parameter has to be returned
  2432.             switch(type) {
  2433.                 case TD_AMBIENT :
  2434.                     marray[0]=surf->ambientColor.r;
  2435.                     marray[1]=surf->ambientColor.g;
  2436.                     marray[2]=surf->ambientColor.b;
  2437.  
  2438.                     break;
  2439.                 case TD_DIFFUSE :
  2440.                     marray[0]=surf->diffuseColor.r;
  2441.                     marray[1]=surf->diffuseColor.g;
  2442.                     marray[2]=surf->diffuseColor.b;
  2443.  
  2444.                     break;
  2445.                 case TD_SHININESS :
  2446.                     marray[0]=UBYTE(surf->shininess*255);
  2447.  
  2448.                     break;
  2449.                 case TD_TRANSPARENCY :
  2450.                     marray[0]=UBYTE(surf->transparency*255);
  2451.  
  2452.                     break;
  2453.                 default :
  2454.                     return(ER_NOTYPE);
  2455.             }
  2456.             break;
  2457.  
  2458.         case TD_TEXTURE :
  2459.             tex=(TDtexture *)mat->handle;
  2460.     
  2461.             break;
  2462.  
  2463.     }
  2464.  
  2465.     return(ER_NOERROR);
  2466. }
  2467.  
  2468. /****** td.library/tdMaterialSetfa ******************************************
  2469. * 
  2470. *   NAME    
  2471. *     tdMaterialSetfa -- Set a parameter of the a material.
  2472. * 
  2473. *   SYNOPSIS
  2474. *    error = tdMaterialSetfa( spacehandle,type,index,array )
  2475. *                             D1          D2   D3     A0
  2476. *
  2477. *    TDerrors tdMaterialSetfa
  2478. *         ( ULONG,TDenum,ULONG,TDfloat * );
  2479. *
  2480. *   FUNCTION
  2481. *    The parameter of the material at index, will be changed.
  2482. *    Type specifies which parameter. The array its size is dependend
  2483. *    of the type.
  2484. * 
  2485. *   INPUTS
  2486. *     spacehandle     - A valid handle of a space.
  2487. *    type            - The parameter its type.
  2488. *    index           - The material its index.
  2489. *    array           - Array which contains the values.
  2490. *    
  2491. *   RESULT
  2492. *     error - ER_NOERROR  if all went well.
  2493. *            ER_NOSPACE  if the handle is not valid.
  2494. *            ER_NOTYPE   if the type is not valid.
  2495. *            ER_NOINDEX  if the index is not valid.
  2496. *
  2497. *   EXAMPLE
  2498. *    error = tdMaterialSetfa(spacehandle,TD_DIFFUSE,7,red);
  2499. *
  2500. *   NOTES
  2501. *    If a value is out of range it will be set to its possible
  2502. *    maximum or minimum.
  2503. *
  2504. *   BUGS
  2505. * 
  2506. *   SEE ALSO
  2507. *     tdMaterialGet()
  2508. * 
  2509. ******************************************************************************
  2510. *
  2511. */
  2512. TDerrors __saveds ASM tdMaterialSetfa(register __d1 ULONG spacehandle,
  2513.                                         register __d2 TDenum type,
  2514.                                         register __d3 ULONG index,
  2515.                                         register __a0 TDfloat *array) {
  2516.     TDspace        *space=NULL;
  2517.     TDmaterialnode    *mat=NULL;
  2518.     TDsurface        *surf=NULL;
  2519.     TDtexture        *tex=NULL;
  2520.     TDfloat        *marray=NULL;
  2521.     TDcolorub        color;
  2522.  
  2523.     // make a copy of the array, because a0 is a scratch register
  2524.     marray = array;
  2525.  
  2526.     space=(TDspace *) spacehandle;
  2527.     if (space==NULL) return(ER_NOSPACE);
  2528.  
  2529.     mat=getMaterialNode(space,index);
  2530.     if(mat==NULL) return(ER_NOINDEX);
  2531.  
  2532.     // do this in function of the material type
  2533.     switch(mat->type) {
  2534.         case TD_SURFACE :
  2535.             surf=(TDsurface *)mat->handle;
  2536.  
  2537.             // check which parameter has to be changed
  2538.             switch(type) {
  2539.                 case TD_AMBIENT :
  2540.                     color.r=UBYTE(marray[0]*255);
  2541.                     color.g=UBYTE(marray[1]*255);
  2542.                     color.b=UBYTE(marray[2]*255);
  2543.  
  2544.                     surf->ambientColor=color;
  2545.  
  2546.                     break;
  2547.                 case TD_DIFFUSE :
  2548.                     color.r=UBYTE(marray[0]*255);
  2549.                     color.g=UBYTE(marray[1]*255);
  2550.                     color.b=UBYTE(marray[2]*255);
  2551.  
  2552.                     surf->diffuseColor=color;
  2553.  
  2554.                     break;
  2555.                 case TD_SHININESS :
  2556.                     if(marray[0]>1.0) surf->shininess=1.0;
  2557.                     else if (marray[0]<0.0) surf->shininess=0.0;
  2558.                     else surf->shininess=marray[0];
  2559.  
  2560.                     break;
  2561.                 case TD_TRANSPARENCY :
  2562.                     if(marray[0]>1.0) surf->transparency=1.0;
  2563.                     else if (marray[0]<0.0) surf->transparency=0.0;
  2564.                     else surf->transparency=marray[0];
  2565.  
  2566.                     break;
  2567.                 default :
  2568.                     return(ER_NOTYPE);
  2569.             }
  2570.             break;
  2571.  
  2572.         case TD_TEXTURE :
  2573.             tex=(TDtexture *)mat->handle;
  2574.  
  2575.             break;
  2576.     }
  2577.  
  2578.     return(ER_NOERROR);
  2579. }
  2580.  
  2581. /****** td.library/tdMaterialGetfa ******************************************
  2582. * 
  2583. *   NAME    
  2584. *     tdMaterialGetfa -- Get a parameter of the a material.
  2585. * 
  2586. *   SYNOPSIS
  2587. *    error = tdMaterialGetfa( spacehandle,type,index,array )
  2588. *                             D1          D2   D3     A0
  2589. *
  2590. *    TDerrors tdMaterialGetfa
  2591. *         ( ULONG,TDenum,ULONG,TDfloat * );
  2592. *
  2593. *   FUNCTION
  2594. *    The parameter of the material at index, will be returned.
  2595. *    Type specifies which parameter. The array its size is dependend
  2596. *    of the type.
  2597. * 
  2598. *   INPUTS
  2599. *     spacehandle     - A valid handle of a space.
  2600. *    type            - The parameter its type.
  2601. *    index           - The material its index.
  2602. *    array           - Pointer to a correct sized array, which
  2603. *                      will contain the values.
  2604. *    
  2605. *   RESULT
  2606. *     error - ER_NOERROR  if all went well.
  2607. *            ER_NOSPACE  if the handle is not valid.
  2608. *            ER_NOTYPE   if the type is not valid.
  2609. *            ER_NOINDEX  if the index is not valid.
  2610. *
  2611. *   EXAMPLE
  2612. *    error = tdMaterialGetfa(spacehandle,TD_DIFFUSE,7,colorarray);
  2613. *
  2614. *   NOTES
  2615. *
  2616. *   BUGS
  2617. * 
  2618. *   SEE ALSO
  2619. *     tdMaterialSet()
  2620. * 
  2621. ******************************************************************************
  2622. *
  2623. */
  2624. TDerrors __saveds ASM tdMaterialGetfa(register __d1 ULONG spacehandle,
  2625.                                         register __d2 TDenum type,
  2626.                                         register __d3 ULONG index,
  2627.                                         register __a0 TDfloat *array) {
  2628.     TDspace        *space=NULL;
  2629.     TDmaterialnode    *mat=NULL;
  2630.     TDsurface        *surf=NULL;
  2631.     TDtexture        *tex=NULL;
  2632.     TDfloat        *marray=NULL;
  2633.  
  2634.     // make a copy of the array, because a0 is a scratch register
  2635.     marray = array;
  2636.  
  2637.     space=(TDspace *) spacehandle;
  2638.     if (space==NULL) return(ER_NOSPACE);
  2639.  
  2640.     mat=getMaterialNode(space,index);
  2641.     if(mat==NULL) return(ER_NOINDEX);
  2642.  
  2643.     // do this in function of the material type
  2644.     switch(mat->type) {
  2645.         case TD_SURFACE :
  2646.             surf=(TDsurface *)mat->handle;
  2647.  
  2648.             // check which parameter has to be returned
  2649.             switch(type) {
  2650.                 case TD_AMBIENT :
  2651.                     marray[0]=surf->ambientColor.r;
  2652.                     marray[0]/=255;
  2653.                     marray[1]=surf->ambientColor.g;
  2654.                     marray[1]/=255;
  2655.                     marray[2]=surf->ambientColor.b;
  2656.                     marray[2]/=255;
  2657.  
  2658.                     break;
  2659.                 case TD_DIFFUSE :
  2660.                     marray[0]=surf->diffuseColor.r;
  2661.                     marray[0]/=255;
  2662.                     marray[1]=surf->diffuseColor.g;
  2663.                     marray[1]/=255;
  2664.                     marray[2]=surf->diffuseColor.b;
  2665.                     marray[2]/=255;
  2666.  
  2667.                     break;
  2668.                 case TD_SHININESS :
  2669.                     marray[0]=surf->shininess;
  2670.  
  2671.                     break;
  2672.                 case TD_TRANSPARENCY :
  2673.                     marray[0]=surf->transparency;
  2674.  
  2675.                     break;
  2676.                 default :
  2677.                     return(ER_NOTYPE);
  2678.             }
  2679.             break;
  2680.  
  2681.         case TD_TEXTURE :
  2682.             tex=(TDtexture *)mat->handle;
  2683.     
  2684.             break;
  2685.     }
  2686.  
  2687.     return(ER_NOERROR);
  2688. }
  2689.  
  2690. /****** td.library/tdMaterialSetf ******************************************
  2691. * 
  2692. *   NAME    
  2693. *     tdMaterialSetf -- Set a single value parameter of the a material.
  2694. * 
  2695. *   SYNOPSIS
  2696. *    error = tdMaterialSetf( spacehandle,type,index,value )
  2697. *                            D1          D2   D3    D4
  2698. *
  2699. *    TDerrors tdMaterialSetf
  2700. *         ( ULONG,TDenum,ULONG,TDfloat );
  2701. *
  2702. *   FUNCTION
  2703. *    A single value parameter of the material at index, will be changed.
  2704. *    Type specifies which parameter.
  2705. * 
  2706. *   INPUTS
  2707. *     spacehandle     - A valid handle of a space.
  2708. *    type            - The parameter its type.
  2709. *    index           - The material its index.
  2710. *    value           - New value of the parameter.
  2711. *    
  2712. *   RESULT
  2713. *     error - ER_NOERROR  if all went well.
  2714. *            ER_NOSPACE  if the handle is not valid.
  2715. *            ER_NOTYPE   if the type is not valid.
  2716. *            ER_NOINDEX  if the index is not valid.
  2717. *
  2718. *   EXAMPLE
  2719. *    error = tdMaterialSetf(spacehandle,TD_SHININESS,23,0.4);
  2720. *
  2721. *   NOTES
  2722. *    If a value is out of range it will be set to its possible
  2723. *    maximum or minimum.
  2724. *
  2725. *   BUGS
  2726. * 
  2727. *   SEE ALSO
  2728. *     tdMaterialGet()
  2729. * 
  2730. ******************************************************************************
  2731. *
  2732. */
  2733. TDerrors __saveds ASM tdMaterialSetf(register __d1 ULONG spacehandle,
  2734.                                     register __d2 TDenum type,
  2735.                                     register __d3 ULONG index,
  2736.                                     register __d4 TDfloat value) {
  2737.     TDspace        *space=NULL;
  2738.     TDmaterialnode    *mat=NULL;
  2739.     TDsurface        *surf=NULL;
  2740.     TDtexture        *tex=NULL;
  2741.  
  2742.     space=(TDspace *) spacehandle;
  2743.     if (space==NULL) return(ER_NOSPACE);
  2744.  
  2745.     mat=getMaterialNode(space,index);
  2746.     if(mat==NULL) return(ER_NOINDEX);
  2747.  
  2748.     // do this in function of the material type
  2749.     switch(mat->type) {
  2750.         case TD_SURFACE :
  2751.             surf=(TDsurface *)mat->handle;
  2752.  
  2753.             // check which parameter has to be changed
  2754.             switch(type) {
  2755.                 case TD_SHININESS :
  2756.                     if(value>1.0) surf->shininess=1.0;
  2757.                     else if (value<0.0) surf->shininess=0.0;
  2758.                     else surf->shininess=value;
  2759.  
  2760.                     break;
  2761.                     case TD_TRANSPARENCY :
  2762.                     if(value>1.0) surf->transparency=1.0;
  2763.                     else if (value<0.0) surf->transparency=0.0;
  2764.                     else surf->transparency=value;
  2765.  
  2766.                     break;
  2767.                 default :
  2768.                     return(ER_NOTYPE);
  2769.             }
  2770.             break;
  2771.  
  2772.         case TD_TEXTURE :
  2773.             tex=(TDtexture *)mat->handle;
  2774.  
  2775.             break;
  2776.     }
  2777.  
  2778.     return(ER_NOERROR);
  2779. }
  2780.  
  2781. /****** td.library/tdMaterialGetf ******************************************
  2782. * 
  2783. *   NAME    
  2784. *     tdMaterialGetf -- Get a single value parameter of the a material.
  2785. * 
  2786. *   SYNOPSIS
  2787. *    error = tdMaterialGetf( spacehandle,type,index,value )
  2788. *                            D1          D2   D3    D4
  2789. *
  2790. *    TDerrors tdMaterialGetf
  2791. *         ( ULONG,TDenum,ULONG,TDfloat * );
  2792. *
  2793. *   FUNCTION
  2794. *    The single value parameter of the material at index, will be returned.
  2795. *    Type specifies which parameter.
  2796. * 
  2797. *   INPUTS
  2798. *     spacehandle     - A valid handle of a space.
  2799. *    type            - The parameter its type.
  2800. *    index           - The material its index.
  2801. *    value           - Pointer to a variable which will contain
  2802. *                      the value.
  2803. *    
  2804. *   RESULT
  2805. *     error - ER_NOERROR  if all went well.
  2806. *            ER_NOSPACE  if the handle is not valid.
  2807. *            ER_NOTYPE   if the type is not valid.
  2808. *            ER_NOINDEX  if the index is not valid.
  2809. *
  2810. *   EXAMPLE
  2811. *    error = tdMaterialGetf(spacehandle,TD_SHININESS,23,&shininess);
  2812. *
  2813. *   NOTES
  2814. *
  2815. *   BUGS
  2816. * 
  2817. *   SEE ALSO
  2818. *     tdMaterialSet()
  2819. * 
  2820. ******************************************************************************
  2821. *
  2822. */
  2823. TDerrors __saveds ASM tdMaterialGetf(register __d1 ULONG spacehandle,
  2824.                                     register __d2 TDenum type,
  2825.                                     register __d3 ULONG index,
  2826.                                     register __d4 TDfloat *value) {
  2827.     TDspace        *space=NULL;
  2828.     TDmaterialnode    *mat=NULL;
  2829.     TDsurface        *surf=NULL;
  2830.     TDtexture        *tex=NULL;
  2831.  
  2832.     space=(TDspace *) spacehandle;
  2833.     if (space==NULL) return(ER_NOSPACE);
  2834.  
  2835.     mat=getMaterialNode(space,index);
  2836.     if(mat==NULL) return(ER_NOINDEX);
  2837.  
  2838.     // do this in function of the material type
  2839.     switch(mat->type) {
  2840.         case TD_SURFACE :
  2841.             surf=(TDsurface *)mat->handle;
  2842.  
  2843.             // check which parameter has to be returned
  2844.             switch(type) {
  2845.                 case TD_SHININESS :
  2846.                     (*value)=surf->shininess;
  2847.  
  2848.                     break;
  2849.                 case TD_TRANSPARENCY :
  2850.                     (*value)=surf->transparency;
  2851.  
  2852.                     break;
  2853.                 default :
  2854.                     return(ER_NOTYPE);
  2855.             }
  2856.             break;
  2857.  
  2858.         case TD_TEXTURE :
  2859.             tex=(TDtexture *)mat->handle;
  2860.  
  2861.             break;
  2862.     }
  2863.  
  2864.     return(ER_NOERROR);
  2865. }
  2866.  
  2867. /****** td.library/tdCTMReset **********************************************
  2868. * 
  2869. *   NAME    
  2870. *     tdCTMReset -- Resets the transformation matrix and
  2871. *                  the scale of the space.
  2872. *
  2873. *   SYNOPSIS
  2874. *    error = tdCTMReset( spacehandle )
  2875. *                        D1
  2876. *
  2877. *    TDerrors tdCTMReset
  2878. *         ( ULONG );
  2879. *
  2880. *   FUNCTION
  2881. *    The translation, rotation and scale factors will be set to
  2882. *    the default values.
  2883. *    Translation is 0, rotation is 0 and scale is 1, for all axis.
  2884. *
  2885. * 
  2886. *   INPUTS
  2887. *     spacehandle   - A valid handle of a space.
  2888. *    
  2889. *   RESULT
  2890. *     error - ER_NOERROR   if all went well.
  2891. *            ER_NOSPACE   if the handle is not valid.
  2892. * 
  2893. *   EXAMPLE
  2894. *    error = tdCTMReset(spacehandle);
  2895. *
  2896. *   NOTES
  2897. *
  2898. *   BUGS
  2899. * 
  2900. *   SEE ALSO
  2901. *     tdTranslationChange(),tdTranslationGet()
  2902. *    tdRotationChange(),tdRotationGet()
  2903. *    tdScaleChange(),tdScaleGet()
  2904. * 
  2905. ******************************************************************************
  2906. *
  2907. */
  2908. TDerrors __saveds ASM tdCTMReset(register __d1 ULONG spacehandle) {
  2909.     TDspace    *space=NULL;
  2910.       
  2911.     space=(TDspace *) spacehandle;
  2912.     if (space==NULL) return(ER_NOSPACE);
  2913.  
  2914.     space->ctm.sx=1,space->ctm.sy=1,space->ctm.sz=1;
  2915.     space->ctm.rx=0,space->ctm.ry=0,space->ctm.rz=0;
  2916.     space->ctm.m[0][0]=1,space->ctm.m[1][0]=0,space->ctm.m[2][0]=0,space->ctm.m[3][0]=0;
  2917.     space->ctm.m[0][1]=0,space->ctm.m[1][1]=1,space->ctm.m[2][1]=0,space->ctm.m[3][1]=0;
  2918.     space->ctm.m[0][2]=0,space->ctm.m[1][2]=0,space->ctm.m[2][2]=1,space->ctm.m[3][2]=0;
  2919.     space->ctm.m[0][3]=0,space->ctm.m[1][3]=0,space->ctm.m[2][3]=0,space->ctm.m[3][3]=1;
  2920.     
  2921.     return(ER_NOERROR);
  2922. }
  2923.  
  2924. /****** td.library/tdCTMChangedv ****************************************
  2925. * 
  2926. *   NAME    
  2927. *     tdCTMChangedv -- Changes a parameter of the CTM of the space.
  2928. *
  2929. *   SYNOPSIS
  2930. *    error = tdCTMChangedv( spacehandle,type,vector,operation )
  2931. *                           D1          D2    A0    D3
  2932. *
  2933. *    TDerrors tdCTMChangedv
  2934. *         ( ULONG,TDenum,TDvectord *,TDenum );
  2935. *
  2936. *   FUNCTION
  2937. *    A parameter of the CTM will be modified in function of the vector
  2938. *    and the operation to perform.
  2939. * 
  2940. *   INPUTS
  2941. *     spacehandle  - A valid handle of a space.
  2942. *    type         - Type of the parameter to change.
  2943. *    vector       - Pointer to a vector structure which contains
  2944. *                   the coordinates..
  2945. *    operation    - A valid CTM operation.
  2946. *
  2947. *   RESULT
  2948. *     error - ER_NOERROR       if all went well.
  2949. *            ER_NOSPACE       if the handle is not valid.
  2950. *            ER_NOTYPE        if the type is not valid.
  2951. *            ER_NOOPERATION   if the operation is not valid.
  2952. * 
  2953. *   EXAMPLE
  2954. *    error = tdCTMChangedv(spacehandle,TD_TRANSLATION,&myvector,myoperation);
  2955. *
  2956. *   NOTES
  2957. *    If you pass 0 values for a division operation,
  2958. *    the corresponding CTM entry will be set to 0.
  2959. *
  2960. *   BUGS
  2961. * 
  2962. *   SEE ALSO
  2963. *     tdCTMReset(),tdCTMGet()
  2964. * 
  2965. ******************************************************************************
  2966. *
  2967. */
  2968. TDerrors __saveds ASM tdCTMChangedv(register __d1 ULONG spacehandle,
  2969.                                     register __d2 TDenum type,
  2970.                                     register __a0 TDvectord *vector,
  2971.                                     register __d3 TDenum operation) {
  2972.                                 
  2973.     TDspace    *space=NULL;
  2974.     TDvectord    *tvector=NULL;
  2975.       
  2976.     // make a copy of vector, a0 is a scratch register
  2977.     tvector=vector;
  2978.     
  2979.     space=(TDspace *) spacehandle;
  2980.     if (space==NULL) return(ER_NOSPACE);
  2981.  
  2982.     // change the parameter
  2983.     switch(type) {
  2984.         case TD_TRANSLATION :
  2985.             if(translationChange(space,(*tvector),operation)) return(ER_NOOPERATION);
  2986.             break;
  2987.         case TD_ROTATION :
  2988.             if(rotationChange(space,(*tvector),operation)) return(ER_NOOPERATION);
  2989.             break;
  2990.         case TD_SCALE :
  2991.             if(scaleChange(space,(*tvector),operation)) return(ER_NOOPERATION);
  2992.             break;
  2993.         default :
  2994.             return(ER_NOTYPE);
  2995.     }
  2996.  
  2997.     return(ER_NOERROR);
  2998. }
  2999.  
  3000. /****** td.library/tdCTMChangefv ****************************************
  3001. * 
  3002. *   NAME    
  3003. *     tdCTMChangefv -- Changes a parameter of the CTM of the space.
  3004. *
  3005. *   SYNOPSIS
  3006. *    error = tdCTMChangefv( spacehandle,type,vector,operation )
  3007. *                           D1          D2    A0    D3
  3008. *
  3009. *    TDerrors tdCTMChangefv
  3010. *         ( ULONG,TDenum,TDvectorf *,TDenum );
  3011. *
  3012. *   FUNCTION
  3013. *    A parameter of the CTM will be modified in function of the vector
  3014. *    and the operation to perform.
  3015. * 
  3016. *   INPUTS
  3017. *     spacehandle  - A valid handle of a space.
  3018. *    type         - Type of the parameter to change.
  3019. *    vector       - Pointer to a vector structure which contains
  3020. *                   the coordinates..
  3021. *    operation    - A valid CTM operation.
  3022. *
  3023. *   RESULT
  3024. *     error - ER_NOERROR       if all went well.
  3025. *            ER_NOSPACE       if the handle is not valid.
  3026. *            ER_NOTYPE        if the type is not valid.
  3027. *            ER_NOOPERATION   if the operation is not valid.
  3028. * 
  3029. *   EXAMPLE
  3030. *    error = tdCTMChangedv(spacehandle,TD_TRANSLATION,&myvector,myoperation);
  3031. *
  3032. *   NOTES
  3033. *    If you pass 0 values for a division operation,
  3034. *    the corresponding CTM entry will be set to 0.
  3035. *
  3036. *   BUGS
  3037. * 
  3038. *   SEE ALSO
  3039. *     tdCTMReset(),tdCTMGet()
  3040. * 
  3041. ******************************************************************************
  3042. *
  3043. */
  3044. TDerrors __saveds ASM tdCTMChangefv(register __d1 ULONG spacehandle,
  3045.                                     register __d2 TDenum type,
  3046.                                     register __a0 TDvectorf *vector,
  3047.                                     register __d3 TDenum operation) {
  3048.                                 
  3049.     TDspace    *space=NULL;
  3050.     TDvectord    tvector;
  3051.       
  3052.     // make a copy of vector, a0 is a scratch register
  3053.     tvector.x=vector->x;
  3054.     tvector.y=vector->y;
  3055.     tvector.z=vector->z;
  3056.     
  3057.     space=(TDspace *) spacehandle;
  3058.     if (space==NULL) return(ER_NOSPACE);
  3059.  
  3060.     // change the parameter
  3061.     switch(type) {
  3062.         case TD_TRANSLATION :
  3063.             if(translationChange(space,tvector,operation)) return(ER_NOOPERATION);
  3064.             break;
  3065.         case TD_ROTATION :
  3066.             if(rotationChange(space,tvector,operation)) return(ER_NOOPERATION);
  3067.             break;
  3068.         case TD_SCALE :
  3069.             if(scaleChange(space,tvector,operation)) return(ER_NOOPERATION);
  3070.             break;
  3071.         default :
  3072.             return(ER_NOTYPE);
  3073.     }
  3074.  
  3075.     return(ER_NOERROR);
  3076. }
  3077.  
  3078. /****** td.library/tdCTMChange3da ****************************************
  3079. * 
  3080. *   NAME    
  3081. *     tdCTMChange3da -- Changes a parameter of the CTM of the space.
  3082. *
  3083. *   SYNOPSIS
  3084. *    error = tdCTMChange3da( spacehandle,type,array,operation )
  3085. *                            D1          D2    A0    D3
  3086. *
  3087. *    TDerrors tdCTMChange3da
  3088. *         ( ULONG,TDenum,TDdouble [3],TDenum );
  3089. *
  3090. *   FUNCTION
  3091. *    A parameter of the CTM will be modified in function of the vector
  3092. *    and the operation to perform.
  3093. * 
  3094. *   INPUTS
  3095. *     spacehandle  - A valid handle of a space.
  3096. *    type         - Type of the parameter to change.
  3097. *    array        - Array which contains the coordinates..
  3098. *    operation    - A valid CTM operation.
  3099. *
  3100. *   RESULT
  3101. *     error - ER_NOERROR       if all went well.
  3102. *            ER_NOSPACE       if the handle is not valid.
  3103. *            ER_NOTYPE        if the type is not valid.
  3104. *            ER_NOOPERATION   if the operation is not valid.
  3105. * 
  3106. *   EXAMPLE
  3107. *    error = tdCTMChange3da(spacehandle,TD_TRANSLATION,myarray,myoperation);
  3108. *
  3109. *   NOTES
  3110. *    If you pass 0 values for a division operation,
  3111. *    the corresponding CTM entry will be set to 0.
  3112. *
  3113. *   BUGS
  3114. * 
  3115. *   SEE ALSO
  3116. *     tdCTMReset(),tdCTMGet()
  3117. * 
  3118. ******************************************************************************
  3119. *
  3120. */
  3121. TDerrors __saveds ASM tdCTMChange3da(register __d1 ULONG spacehandle,
  3122.                                     register __d2 TDenum type,
  3123.                                     register __a0 TDdouble array[3],
  3124.                                     register __d3 TDenum operation) {
  3125.                                 
  3126.     TDspace    *space=NULL;
  3127.     TDvectord    tvector;
  3128.       
  3129.     // make a copy of vector, a0 is a scratch register
  3130.     tvector.x=array[0];
  3131.     tvector.y=array[1];
  3132.     tvector.z=array[2];
  3133.     
  3134.     space=(TDspace *) spacehandle;
  3135.     if (space==NULL) return(ER_NOSPACE);
  3136.  
  3137.     // change the parameter
  3138.     switch(type) {
  3139.         case TD_TRANSLATION :
  3140.             if(translationChange(space,tvector,operation)) return(ER_NOOPERATION);
  3141.             break;
  3142.         case TD_ROTATION :
  3143.             if(rotationChange(space,tvector,operation)) return(ER_NOOPERATION);
  3144.             break;
  3145.         case TD_SCALE :
  3146.             if(scaleChange(space,tvector,operation)) return(ER_NOOPERATION);
  3147.             break;
  3148.         default :
  3149.             return(ER_NOTYPE);
  3150.     }
  3151.  
  3152.     return(ER_NOERROR);
  3153. }
  3154.  
  3155. /****** td.library/tdCTMChange3fa ****************************************
  3156. * 
  3157. *   NAME    
  3158. *     tdCTMChange3fa -- Changes a parameter of the CTM of the space.
  3159. *
  3160. *   SYNOPSIS
  3161. *    error = tdCTMChange3fa( spacehandle,type,array,operation )
  3162. *                            D1          D2    A0    D3
  3163. *
  3164. *    TDerrors tdCTMChange3fa
  3165. *         ( ULONG,TDenum,TDfloat [3],TDenum );
  3166. *
  3167. *   FUNCTION
  3168. *    A parameter of the CTM will be modified in function of the vector
  3169. *    and the operation to perform.
  3170. * 
  3171. *   INPUTS
  3172. *     spacehandle  - A valid handle of a space.
  3173. *    type         - Type of the parameter to change.
  3174. *    array        - Array which contains the coordinates..
  3175. *    operation    - A valid CTM operation.
  3176. *
  3177. *   RESULT
  3178. *     error - ER_NOERROR       if all went well.
  3179. *            ER_NOSPACE       if the handle is not valid.
  3180. *            ER_NOTYPE        if the type is not valid.
  3181. *            ER_NOOPERATION   if the operation is not valid.
  3182. * 
  3183. *   EXAMPLE
  3184. *    error = tdCTMChange3fa(spacehandle,TD_TRANSLATION,myarray,myoperation);
  3185. *
  3186. *   NOTES
  3187. *    If you pass 0 values for a division operation,
  3188. *    the corresponding CTM entry will be set to 0.
  3189. *
  3190. *   BUGS
  3191. * 
  3192. *   SEE ALSO
  3193. *     tdCTMReset(),tdCTMGet()
  3194. * 
  3195. ******************************************************************************
  3196. *
  3197. */
  3198. TDerrors __saveds ASM tdCTMChange3fa(register __d1 ULONG spacehandle,
  3199.                                     register __d2 TDenum type,
  3200.                                     register __a0 TDfloat array[3],
  3201.                                     register __d3 TDenum operation) {
  3202.                                 
  3203.     TDspace    *space=NULL;
  3204.     TDvectord    tvector;
  3205.       
  3206.     // make a copy of vector, a0 is a scratch register
  3207.     tvector.x=array[0];
  3208.     tvector.y=array[1];
  3209.     tvector.z=array[2];
  3210.     
  3211.     space=(TDspace *) spacehandle;
  3212.     if (space==NULL) return(ER_NOSPACE);
  3213.  
  3214.     // change the parameter
  3215.     switch(type) {
  3216.         case TD_TRANSLATION :
  3217.             if(translationChange(space,tvector,operation)) return(ER_NOOPERATION);
  3218.             break;
  3219.         case TD_ROTATION :
  3220.             if(rotationChange(space,tvector,operation)) return(ER_NOOPERATION);
  3221.             break;
  3222.         case TD_SCALE :
  3223.             if(scaleChange(space,tvector,operation)) return(ER_NOOPERATION);
  3224.             break;
  3225.         default :
  3226.             return(ER_NOTYPE);
  3227.     }
  3228.  
  3229.     return(ER_NOERROR);
  3230. }
  3231.  
  3232. /****** td.library/tdCTMGetdv ******************************************
  3233. * 
  3234. *   NAME    
  3235. *     tdCTMGetdv -- Get a parameter of the space its CTM.
  3236. *
  3237. *   SYNOPSIS
  3238. *    error = tdCTMGetdv( spacehandle,type,vector )
  3239. *                        D1          D2    A0
  3240. *
  3241. *    TDerrors tdCTMGetdv
  3242. *         ( ULONG,TDenum,TDvectord * );
  3243. *
  3244. *   FUNCTION
  3245. *    A parameter of the CTM will be returned in the passed
  3246. *    vector structure.
  3247. * 
  3248. *   INPUTS
  3249. *     spacehandle  - A valid handle of a space.
  3250. *    type         - The type of the parameter to return.
  3251. *    vector       - Pointer to a vertex structure which will
  3252. *                   contain the values.
  3253. *
  3254. *   RESULT
  3255. *     error - ER_NOERROR  if all went well.
  3256. *            ER_NOSPACE  if the handle is not valid.
  3257. * 
  3258. *   EXAMPLE
  3259. *    error = tdCTMGetdv(spacehandle,TD_ROTATION,&myvector);
  3260. *
  3261. *   NOTES
  3262. *
  3263. *   BUGS
  3264. * 
  3265. *   SEE ALSO
  3266. *     tdCTMReset(),tdCTMChange()
  3267. * 
  3268. ******************************************************************************
  3269. *
  3270. */
  3271. TDerrors __saveds ASM tdCTMGetdv(register __d1 ULONG spacehandle,
  3272.                                 register __d2 TDenum type,
  3273.                                 register __a0 TDvectord *vector) {
  3274.                                 
  3275.     TDspace    *space=NULL;
  3276.     TDvectord    *tvector=NULL;
  3277.       
  3278.     // make a copy of translation vertex, a0 is a scratch register
  3279.     tvector=vector;
  3280.     
  3281.     space=(TDspace *) spacehandle;
  3282.     if (space==NULL) return(ER_NOSPACE);
  3283.  
  3284.     switch(type) {
  3285.         case TD_TRANSLATION :
  3286.             tvector->x=space->ctm.m[3][0];
  3287.             tvector->y=space->ctm.m[3][1];
  3288.             tvector->z=space->ctm.m[3][2];
  3289.             break;
  3290.         case TD_SCALE :
  3291.             tvector->x=space->ctm.sx;
  3292.             tvector->y=space->ctm.sy;
  3293.             tvector->z=space->ctm.sz;
  3294.             break;
  3295.         case TD_ROTATION :
  3296.             tvector->x=space->ctm.rx;
  3297.             tvector->y=space->ctm.ry;
  3298.             tvector->z=space->ctm.rz;
  3299.         default :
  3300.             return(ER_NOTYPE);
  3301.     }
  3302.  
  3303.     return(ER_NOERROR);
  3304. }
  3305.  
  3306. /****** td.library/tdCTMGetfv ******************************************
  3307. * 
  3308. *   NAME    
  3309. *     tdCTMGetfv -- Get a parameter of the space its CTM.
  3310. *
  3311. *   SYNOPSIS
  3312. *    error = tdCTMGetfv( spacehandle,type,vector )
  3313. *                        D1          D2    A0
  3314. *
  3315. *    TDerrors tdCTMGetfv
  3316. *         ( ULONG,TDenum,TDvectorf * );
  3317. *
  3318. *   FUNCTION
  3319. *    A parameter of the CTM will be returned in the passed
  3320. *    vector structure.
  3321. * 
  3322. *   INPUTS
  3323. *     spacehandle  - A valid handle of a space.
  3324. *    type         - The type of the parameter to return.
  3325. *    vector       - Pointer to a vertex structure which will
  3326. *                   contain the values.
  3327. *
  3328. *   RESULT
  3329. *     error - ER_NOERROR  if all went well.
  3330. *            ER_NOSPACE  if the handle is not valid.
  3331. * 
  3332. *   EXAMPLE
  3333. *    error = tdCTMGetfv(spacehandle,TD_ROTATION,&myvector);
  3334. *
  3335. *   NOTES
  3336. *
  3337. *   BUGS
  3338. * 
  3339. *   SEE ALSO
  3340. *     tdCTMReset(),tdCTMChange()
  3341. * 
  3342. ******************************************************************************
  3343. *
  3344. */
  3345. TDerrors __saveds ASM tdCTMGetfv(register __d1 ULONG spacehandle,
  3346.                                 register __d2 TDenum type,
  3347.                                 register __a0 TDvectorf *vector) {
  3348.                                 
  3349.     TDspace    *space=NULL;
  3350.     TDvectorf    *tvector=NULL;
  3351.       
  3352.     // make a copy of translation vertex, a0 is a scratch register
  3353.     tvector=vector;
  3354.     
  3355.     space=(TDspace *) spacehandle;
  3356.     if (space==NULL) return(ER_NOSPACE);
  3357.  
  3358.     switch(type) {
  3359.         case TD_TRANSLATION :
  3360.             tvector->x=space->ctm.m[3][0];
  3361.             tvector->y=space->ctm.m[3][1];
  3362.             tvector->z=space->ctm.m[3][2];
  3363.             break;
  3364.         case TD_SCALE :
  3365.             tvector->x=space->ctm.sx;
  3366.             tvector->y=space->ctm.sy;
  3367.             tvector->z=space->ctm.sz;
  3368.             break;
  3369.         case TD_ROTATION :
  3370.             tvector->x=space->ctm.rx;
  3371.             tvector->y=space->ctm.ry;
  3372.             tvector->z=space->ctm.rz;
  3373.         default :
  3374.             return(ER_NOTYPE);
  3375.     }
  3376.  
  3377.     return(ER_NOERROR);
  3378. }
  3379.  
  3380. /****** td.library/tdCTMGet3da ******************************************
  3381. * 
  3382. *   NAME    
  3383. *     tdCTMGet3da -- Get a parameter of the space its CTM.
  3384. *
  3385. *   SYNOPSIS
  3386. *    error = tdCTMGet3da( spacehandle,type,array )
  3387. *                        D1          D2     A0
  3388. *
  3389. *    TDerrors tdCTMGet3da
  3390. *         ( ULONG,TDenum,TDdouble [3] );
  3391. *
  3392. *   FUNCTION
  3393. *    A parameter of the CTM will be returned in the passed
  3394. *    vector structure.
  3395. * 
  3396. *   INPUTS
  3397. *     spacehandle  - A valid handle of a space.
  3398. *    type         - The type of the parameter to return.
  3399. *    array        - Array which will contain the values.
  3400. *
  3401. *   RESULT
  3402. *     error - ER_NOERROR  if all went well.
  3403. *            ER_NOSPACE  if the handle is not valid.
  3404. * 
  3405. *   EXAMPLE
  3406. *    error = tdCTMGet3da(spacehandle,TD_ROTATION,myarray);
  3407. *
  3408. *   NOTES
  3409. *
  3410. *   BUGS
  3411. * 
  3412. *   SEE ALSO
  3413. *     tdCTMReset(),tdCTMChange()
  3414. * 
  3415. ******************************************************************************
  3416. *
  3417. */
  3418. TDerrors __saveds ASM tdCTMGet3da(register __d1 ULONG spacehandle,
  3419.                                 register __d2 TDenum type,
  3420.                                 register __a0 TDdouble array[3]) {
  3421.                                 
  3422.     TDspace    *space=NULL;
  3423.     TDdouble    *marray=NULL;
  3424.       
  3425.     // make a copy of translation vertex, a0 is a scratch register
  3426.     marray=array;
  3427.     
  3428.     space=(TDspace *) spacehandle;
  3429.     if (space==NULL) return(ER_NOSPACE);
  3430.  
  3431.     switch(type) {
  3432.         case TD_TRANSLATION :
  3433.             marray[0]=space->ctm.m[3][0];
  3434.             marray[1]=space->ctm.m[3][1];
  3435.             marray[2]=space->ctm.m[3][2];
  3436.             break;
  3437.         case TD_SCALE :
  3438.             marray[0]=space->ctm.sx;
  3439.             marray[1]=space->ctm.sy;
  3440.             marray[2]=space->ctm.sz;
  3441.             break;
  3442.         case TD_ROTATION :
  3443.             marray[0]=space->ctm.rx;
  3444.             marray[1]=space->ctm.ry;
  3445.             marray[2]=space->ctm.rz;
  3446.         default :
  3447.             return(ER_NOTYPE);
  3448.     }
  3449.  
  3450.     return(ER_NOERROR);
  3451. }
  3452.  
  3453. /****** td.library/tdCTMGet3fa ******************************************
  3454. * 
  3455. *   NAME    
  3456. *     tdCTMGet3fa -- Get a parameter of the space its CTM.
  3457. *
  3458. *   SYNOPSIS
  3459. *    error = tdCTMGet3fa( spacehandle,type,array )
  3460. *                        D1          D2     A0
  3461. *
  3462. *    TDerrors tdCTMGet3fa
  3463. *         ( ULONG,TDenum,TDfloat [3] );
  3464. *
  3465. *   FUNCTION
  3466. *    A parameter of the CTM will be returned in the passed
  3467. *    vector structure.
  3468. * 
  3469. *   INPUTS
  3470. *     spacehandle  - A valid handle of a space.
  3471. *    type         - The type of the parameter to return.
  3472. *    array        - Array which will contain the values.
  3473. *
  3474. *   RESULT
  3475. *     error - ER_NOERROR  if all went well.
  3476. *            ER_NOSPACE  if the handle is not valid.
  3477. * 
  3478. *   EXAMPLE
  3479. *    error = tdCTMGet3fa(spacehandle,TD_ROTATION,myarray);
  3480. *
  3481. *   NOTES
  3482. *
  3483. *   BUGS
  3484. * 
  3485. *   SEE ALSO
  3486. *     tdCTMReset(),tdCTMChange()
  3487. * 
  3488. ******************************************************************************
  3489. *
  3490. */
  3491. TDerrors __saveds ASM tdCTMGet3fa(register __d1 ULONG spacehandle,
  3492.                                 register __d2 TDenum type,
  3493.                                 register __a0 TDfloat array[3]) {
  3494.                                 
  3495.     TDspace    *space=NULL;
  3496.     TDfloat    *marray=NULL;
  3497.       
  3498.     // make a copy of translation vertex, a0 is a scratch register
  3499.     marray=array;
  3500.     
  3501.     space=(TDspace *) spacehandle;
  3502.     if (space==NULL) return(ER_NOSPACE);
  3503.  
  3504.     switch(type) {
  3505.         case TD_TRANSLATION :
  3506.             marray[0]=space->ctm.m[3][0];
  3507.             marray[1]=space->ctm.m[3][1];
  3508.             marray[2]=space->ctm.m[3][2];
  3509.             break;
  3510.         case TD_SCALE :
  3511.             marray[0]=space->ctm.sx;
  3512.             marray[1]=space->ctm.sy;
  3513.             marray[2]=space->ctm.sz;
  3514.             break;
  3515.         case TD_ROTATION :
  3516.             marray[0]=space->ctm.rx;
  3517.             marray[1]=space->ctm.ry;
  3518.             marray[2]=space->ctm.rz;
  3519.         default :
  3520.             return(ER_NOTYPE);
  3521.     }
  3522.  
  3523.     return(ER_NOERROR);
  3524. }
  3525.  
  3526. /****** td.library/tdObjectSetfa ******************************************
  3527. * 
  3528. *   NAME    
  3529. *     tdObjectSetfa -- Set a parameter of the an object.
  3530. * 
  3531. *   SYNOPSIS
  3532. *    error = tdObjectSetfa( spacehandle,type,index,array )
  3533. *                           D1          D2   D3     A0
  3534. *
  3535. *    TDerrors tdObjectSetfa
  3536. *         ( ULONG,TDenum,ULONG,TDfloat * );
  3537. *
  3538. *   FUNCTION
  3539. *    The parameter of the object at index, will be changed.
  3540. *    Type specifies which parameter. The array its size is dependend
  3541. *    of the type.
  3542. * 
  3543. *   INPUTS
  3544. *     spacehandle     - A valid handle of a space.
  3545. *    type            - The parameter its type.
  3546. *    index           - The parameter its index.
  3547. *    array           - Array which contains the values.
  3548. *    
  3549. *   RESULT
  3550. *     error - ER_NOERROR  if all went well.
  3551. *            ER_NOSPACE  if the handle is not valid.
  3552. *            ER_NOTYPE   if the type is not valid.
  3553. *            ER_NOINDEX  if the index is not valid.
  3554. *
  3555. *   EXAMPLE
  3556. *    error = tdObjectSetfa(spacehandle,TD_CUBE,7,size);
  3557. *
  3558. *   NOTES
  3559. *    If a value is out of range it will be set to its possible
  3560. *    maximum or minimum.
  3561. *
  3562. *   BUGS
  3563. * 
  3564. *   SEE ALSO
  3565. *     tdObjectGet()
  3566. * 
  3567. ******************************************************************************
  3568. *
  3569. */
  3570. TDerrors __saveds ASM tdObjectSetfa(register __d1 ULONG spacehandle,
  3571.                                     register __d2 TDenum type,
  3572.                                     register __d3 ULONG index,
  3573.                                     register __a0 TDfloat *array) {
  3574.     TDspace        *space=NULL;
  3575.     TDobjectnode    *object=NULL;
  3576.     TDcube            *cube=NULL;
  3577.     TDfloat        *marray=NULL;
  3578.  
  3579.     // make a copy of the array, because a0 is a scratch register
  3580.     marray = array;
  3581.  
  3582.     space=(TDspace *) spacehandle;
  3583.     if (space==NULL) return(ER_NOSPACE);
  3584.  
  3585.     object=getObjectNode(space,index);
  3586.     if(object==NULL) return(ER_NOINDEX);
  3587.  
  3588.     // check which parameter has to be changed
  3589.     switch(type) {
  3590.         case TD_ORIGIN :
  3591.             object->o.x=marray[0];
  3592.             object->o.y=marray[1];
  3593.             object->o.z=marray[2];
  3594.             
  3595.             break;
  3596.         case TD_ROTATION :
  3597.             object->r.x=marray[0];
  3598.             object->r.y=marray[1];
  3599.             object->r.z=marray[2];
  3600.             
  3601.             break;
  3602.         case TD_SCALE :
  3603.             object->s.x=marray[0];
  3604.             object->s.y=marray[1];
  3605.             object->s.z=marray[2];
  3606.             
  3607.             break;
  3608.         case TD_CUBE :
  3609.             if(object->type!=TD_CUBE) {
  3610.                 return(ER_NOTYPE);
  3611.             }
  3612.             cube=(TDcube *)object->handle;
  3613.             
  3614.             cube->size.x=marray[0];
  3615.             cube->size.y=marray[1];
  3616.             cube->size.z=marray[2];
  3617.  
  3618.             break;
  3619.         default :
  3620.             return(ER_NOTYPE);
  3621.     }
  3622.  
  3623.     return(ER_NOERROR);
  3624. }
  3625.  
  3626. /****** td.library/tdObjectGetfa ******************************************
  3627. * 
  3628. *   NAME    
  3629. *     tdObjectGetfa -- Get a parameter of the a object.
  3630. * 
  3631. *   SYNOPSIS
  3632. *    error = tdObjectGetfa( spacehandle,type,index,array )
  3633. *                           D1          D2   D3     A0
  3634. *
  3635. *    TDerrors tdObjectGetfa
  3636. *         ( ULONG,TDenum,ULONG,TDfloat * );
  3637. *
  3638. *   FUNCTION
  3639. *    The parameter of the object at index, will be returned.
  3640. *    Type specifies which parameter. The array its size is dependend
  3641. *    of the type.
  3642. * 
  3643. *   INPUTS
  3644. *     spacehandle     - A valid handle of a space.
  3645. *    type            - The parameter its type.
  3646. *    index           - The parameter its index.
  3647. *    array           - Pointer to a correct sized array, which
  3648. *                      will contain the values.
  3649. *    
  3650. *   RESULT
  3651. *     error - ER_NOERROR  if all went well.
  3652. *            ER_NOSPACE  if the handle is not valid.
  3653. *            ER_NOTYPE   if the type is not valid.
  3654. *            ER_NOINDEX  if the index is not valid.
  3655. *
  3656. *   EXAMPLE
  3657. *    error = tdObjectGetfa(spacehandle,TD_ORIGIN,12,array);
  3658. *
  3659. *   NOTES
  3660. *
  3661. *   BUGS
  3662. * 
  3663. *   SEE ALSO
  3664. *     tdObjectSet()
  3665. * 
  3666. ******************************************************************************
  3667. *
  3668. */
  3669. TDerrors __saveds ASM tdObjectGetfa(register __d1 ULONG spacehandle,
  3670.                                     register __d2 TDenum type,
  3671.                                     register __d3 ULONG index,
  3672.                                     register __a0 TDfloat *array) {
  3673.     TDspace        *space=NULL;
  3674.     TDobjectnode    *object=NULL;
  3675.     TDcube            *cube=NULL;
  3676.     TDfloat        *marray=NULL;
  3677.  
  3678.     // make a copy of the array, because a0 is a scratch register
  3679.     marray = array;
  3680.  
  3681.     space=(TDspace *) spacehandle;
  3682.     if (space==NULL) return(ER_NOSPACE);
  3683.  
  3684.     object=getObjectNode(space,index);
  3685.     if(object==NULL) return(ER_NOINDEX);
  3686.  
  3687.     // check which parameter has to be returned
  3688.     switch(type) {
  3689.         case TD_ORIGIN :
  3690.             marray[0]=object->o.x;
  3691.             marray[1]=object->o.y;
  3692.             marray[2]=object->o.z;
  3693.             
  3694.             break;
  3695.         case TD_ROTATION :
  3696.             marray[0]=object->r.x;
  3697.             marray[1]=object->r.y;
  3698.             marray[2]=object->r.z;
  3699.             
  3700.             break;
  3701.         case TD_SCALE :
  3702.             marray[0]=object->s.x;
  3703.             marray[1]=object->s.y;
  3704.             marray[2]=object->s.z;
  3705.             
  3706.             break;
  3707.         case TD_CUBE :
  3708.             if(object->type!=TD_CUBE) {
  3709.                 return(ER_NOTYPE);
  3710.             }
  3711.  
  3712.             cube=(TDcube *)object->handle;
  3713.  
  3714.             marray[0]=cube->size.x;
  3715.             marray[1]=cube->size.y;
  3716.             marray[2]=cube->size.z;
  3717.  
  3718.             break;
  3719.         default :
  3720.             return(ER_NOTYPE);
  3721.     }
  3722.  
  3723.     return(ER_NOERROR);
  3724. }
  3725.  
  3726. /****** td.library/tdObjectSetda ******************************************
  3727. * 
  3728. *   NAME    
  3729. *     tdObjectSetda -- Set a parameter of the a object.
  3730. * 
  3731. *   SYNOPSIS
  3732. *    error = tdObjectSetda( spacehandle,type,index,array )
  3733. *                           D1          D2   D3     A0
  3734. *
  3735. *    TDerrors tdObjectSetfa
  3736. *         ( ULONG,TDenum,ULONG,TDdouble * );
  3737. *
  3738. *   FUNCTION
  3739. *    The parameter of the object at index, will be changed.
  3740. *    Type specifies which parameter. The array its size is dependend
  3741. *    of the type.
  3742. * 
  3743. *   INPUTS
  3744. *     spacehandle     - A valid handle of a space.
  3745. *    type            - The parameter its type.
  3746. *    index           - The parameter its index.
  3747. *    array           - Array which contains the values.
  3748. *    
  3749. *   RESULT
  3750. *     error - ER_NOERROR  if all went well.
  3751. *            ER_NOSPACE  if the handle is not valid.
  3752. *            ER_NOTYPE   if the type is not valid.
  3753. *            ER_NOINDEX  if the index is not valid.
  3754. *
  3755. *   EXAMPLE
  3756. *    error = tdObjectSetda(spacehandle,TD_ORIGIN,2,origin);
  3757. *
  3758. *   NOTES
  3759. *
  3760. *   BUGS
  3761. * 
  3762. *   SEE ALSO
  3763. *     tdObjectGet()
  3764. * 
  3765. ******************************************************************************
  3766. *
  3767. */
  3768. TDerrors __saveds ASM tdObjectSetda(register __d1 ULONG spacehandle,
  3769.                                     register __d2 TDenum type,
  3770.                                     register __d3 ULONG index,
  3771.                                     register __a0 TDdouble *array) {
  3772.     TDspace        *space=NULL;
  3773.     TDobjectnode    *object=NULL;
  3774.     TDcube            *cube=NULL;
  3775.     TDdouble        *marray=NULL;
  3776.  
  3777.     // make a copy of the array, because a0 is a scratch register
  3778.     marray = array;
  3779.  
  3780.     space=(TDspace *) spacehandle;
  3781.     if (space==NULL) return(ER_NOSPACE);
  3782.  
  3783.     object=getObjectNode(space,index);
  3784.     if(object==NULL) return(ER_NOINDEX);
  3785.  
  3786.     // check which parameter has to be changed
  3787.     switch(type) {
  3788.         case TD_ORIGIN :
  3789.             object->o.x=marray[0];
  3790.             object->o.y=marray[1];
  3791.             object->o.z=marray[2];
  3792.             
  3793.             break;
  3794.         case TD_ROTATION :
  3795.             object->r.x=marray[0];
  3796.             object->r.y=marray[1];
  3797.             object->r.z=marray[2];
  3798.             
  3799.             break;
  3800.         case TD_SCALE :
  3801.             object->s.x=marray[0];
  3802.             object->s.y=marray[1];
  3803.             object->s.z=marray[2];
  3804.             
  3805.             break;
  3806.         case TD_CUBE :
  3807.             if(object->type!=TD_CUBE) {
  3808.                 return(ER_NOTYPE);
  3809.             }
  3810.             cube=(TDcube *)object->handle;
  3811.             
  3812.             cube->size.x=marray[0];
  3813.             cube->size.y=marray[1];
  3814.             cube->size.z=marray[2];
  3815.  
  3816.             break;
  3817.         default :
  3818.             return(ER_NOTYPE);
  3819.     }
  3820.  
  3821.     return(ER_NOERROR);
  3822. }
  3823.  
  3824. /****** td.library/tdObjectGetda ******************************************
  3825. * 
  3826. *   NAME    
  3827. *     tdObjectGetda -- Get a parameter of the a object.
  3828. * 
  3829. *   SYNOPSIS
  3830. *    error = tdObjectGetda( spacehandle,type,index,array )
  3831. *                           D1          D2   D3     A0
  3832. *
  3833. *    TDerrors tdObjectGetfa
  3834. *         ( ULONG,TDenum,ULONG,TDdouble * );
  3835. *
  3836. *   FUNCTION
  3837. *    The parameter of the object at index, will be returned.
  3838. *    Type specifies which parameter. The array its size is dependend
  3839. *    of the type.
  3840. * 
  3841. *   INPUTS
  3842. *     spacehandle     - A valid handle of a space.
  3843. *    type            - The parameter its type.
  3844. *    index           - The parameter its index.
  3845. *    array           - Pointer to a correct sized array, which
  3846. *                      will contain the values.
  3847. *    
  3848. *   RESULT
  3849. *     error - ER_NOERROR  if all went well.
  3850. *            ER_NOSPACE  if the handle is not valid.
  3851. *            ER_NOTYPE   if the type is not valid.
  3852. *            ER_NOINDEX  if the index is not valid.
  3853. *
  3854. *   EXAMPLE
  3855. *    error = tdObjectGetda(spacehandle,TD_SCALE,3,array);
  3856. *
  3857. *   NOTES
  3858. *    If a value is out of range it will be set to its possible
  3859. *    maximum or minimum.
  3860. *
  3861. *   BUGS
  3862. * 
  3863. *   SEE ALSO
  3864. *     tdObjectSet()
  3865. * 
  3866. ******************************************************************************
  3867. *
  3868. */
  3869. TDerrors __saveds ASM tdObjectGetda(register __d1 ULONG spacehandle,
  3870.                                     register __d2 TDenum type,
  3871.                                     register __d3 ULONG index,
  3872.                                     register __a0 TDdouble *array) {
  3873.     TDspace        *space=NULL;
  3874.     TDobjectnode    *object=NULL;
  3875.     TDcube            *cube=NULL;
  3876.     TDdouble        *marray=NULL;
  3877.  
  3878.     // make a copy of the array, because a0 is a scratch register
  3879.     marray = array;
  3880.  
  3881.     space=(TDspace *) spacehandle;
  3882.     if (space==NULL) return(ER_NOSPACE);
  3883.  
  3884.     object=getObjectNode(space,index);
  3885.     if(object==NULL) return(ER_NOINDEX);
  3886.  
  3887.     // check which parameter has to be returned
  3888.     switch(type) {
  3889.         case TD_ORIGIN :
  3890.             marray[0]=object->o.x;
  3891.             marray[1]=object->o.y;
  3892.             marray[2]=object->o.z;
  3893.             
  3894.             break;
  3895.         case TD_ROTATION :
  3896.             marray[0]=object->r.x;
  3897.             marray[1]=object->r.y;
  3898.             marray[2]=object->r.z;
  3899.  
  3900.             break;
  3901.         case TD_SCALE :
  3902.             marray[0]=object->s.x;
  3903.             marray[1]=object->s.y;
  3904.             marray[2]=object->s.z;
  3905.             
  3906.             break;
  3907.         case TD_CUBE :
  3908.             if(object->type!=TD_CUBE) {
  3909.                 return(ER_NOTYPE);
  3910.             }
  3911.  
  3912.             cube=(TDcube *)object->handle;
  3913.  
  3914.             marray[0]=cube->size.x;
  3915.             marray[1]=cube->size.y;
  3916.             marray[2]=cube->size.z;
  3917.  
  3918.             break;
  3919.         default :
  3920.             return(ER_NOTYPE);
  3921.     }
  3922.  
  3923.     return(ER_NOERROR);
  3924. }
  3925.  
  3926. /****** td.library/tdTypeGet ******************************************
  3927. * 
  3928. *   NAME    
  3929. *     tdTypeGet -- Get the real type of a component in the space.
  3930. * 
  3931. *   SYNOPSIS
  3932. *    error = tdGetType( spacehandle,type,index,rtype )
  3933. *                       D1          D2   D3    D4
  3934. *
  3935. *    TDerrors tdTypeGet
  3936. *         ( ULONG,TDenum,ULONG,TDenum * );
  3937. *
  3938. *   FUNCTION
  3939. *    The component of the space at index its real type will
  3940. *    be returned.
  3941. *    Type specifies which component.
  3942. * 
  3943. *   INPUTS
  3944. *     spacehandle     - A valid handle of a space.
  3945. *    type            - The component its type.
  3946. *    index           - The parameter its index.
  3947. *    rtype           - Pointer to a variable, which
  3948. *                      will contain the real type.
  3949. *    
  3950. *   RESULT
  3951. *     error - ER_NOERROR  if all went well.
  3952. *            ER_NOSPACE  if the handle is not valid.
  3953. *            ER_NOTYPE   if the type is not valid.
  3954. *            ER_NOINDEX  if the index is not valid.
  3955. *
  3956. *   EXAMPLE
  3957. *    error = tdTypeGet(spacehandle,TD_OBJECT,45,type);
  3958. *
  3959. *   NOTES
  3960. *    For example : TD_OBJECT which is the parent type
  3961. *    and the real type is TD_CUBE.
  3962. *
  3963. *   BUGS
  3964. * 
  3965. *   SEE ALSO
  3966. * 
  3967. ******************************************************************************
  3968. *
  3969. */
  3970. TDerrors __saveds ASM tdTypeGet(register __d1 ULONG spacehandle,
  3971.                                 register __d2 TDenum type,
  3972.                                 register __d3 ULONG index,
  3973.                                 register __d4 TDenum *rtype) {
  3974.     TDspace        *space=NULL;
  3975.     TDobjectnode    *object=NULL;
  3976.     TDmaterialnode    *mat=NULL;
  3977.  
  3978.     space=(TDspace *) spacehandle;
  3979.     if (space==NULL) return(ER_NOSPACE);
  3980.  
  3981.     // search for the real type
  3982.     switch(type) {
  3983.         case TD_OBJECT :
  3984.             object=getObjectNode(space,index);
  3985.             if(object==NULL) return(ER_NOINDEX);
  3986.  
  3987.             (*rtype)=object->type;
  3988.  
  3989.             break;
  3990.         case TD_MATERIAL :
  3991.             mat=getMaterialNode(space,index);
  3992.             if(mat==NULL) return(ER_NOINDEX);
  3993.  
  3994.             (*rtype)=mat->type;
  3995.  
  3996.             break;
  3997.         default :
  3998.             return(ER_NOTYPE);
  3999.     }
  4000.  
  4001.     return(ER_NOERROR);
  4002. }
  4003.  
  4004. /****** td.library/tdCurrent ******************************************
  4005. * 
  4006. *   NAME    
  4007. *     tdCurrent -- Set the component to work with.
  4008. * 
  4009. *   SYNOPSIS
  4010. *    error = tdCurrent( spacehandle,type,index)
  4011. *                       D1          D2   D3
  4012. *
  4013. *    TDerrors tdCurrent
  4014. *         ( ULONG,TDenum,ULONG );
  4015. *
  4016. *   FUNCTION
  4017. *    The component of the space at index will be used for
  4018. *    further special operations.
  4019. *    Type specifies which component.
  4020. * 
  4021. *   INPUTS
  4022. *     spacehandle     - A valid handle of a space.
  4023. *    type            - The component its type.
  4024. *    index           - The component its index.
  4025. *    
  4026. *   RESULT
  4027. *     error - ER_NOERROR     if all went well.
  4028. *            ER_NOSPACE     if the handle is not valid.
  4029. *            ER_NOOBJECT    if there is no current object.
  4030. *            ER_NOMATGROUP  if there is no current material group.
  4031. *            ER_NOTYPE      if the type is not valid.
  4032. *            ER_NOINDEX     if the index is not valid.
  4033. *
  4034. *   EXAMPLE
  4035. *    error = tdCurrent(spacehandle,TD_OBJECT,5);
  4036. *
  4037. *   NOTES
  4038. *
  4039. *   BUGS
  4040. * 
  4041. *   SEE ALSO
  4042. *     tdBegin(),tdEnd()
  4043. * 
  4044. ******************************************************************************
  4045. *
  4046. */
  4047. TDerrors __saveds ASM tdCurrent(register __d1 ULONG spacehandle,
  4048.                                 register __d2 TDenum type,
  4049.                                 register __d3 ULONG index ) {
  4050.     TDspace        *space=NULL;
  4051.     TDpolymesh        *polymesh=NULL;
  4052.     TDmatgroupnode    *matgroupn=NULL;
  4053.     TDpolygonnode    *polyn=NULL;
  4054.  
  4055.     space=(TDspace *) spacehandle;
  4056.     if (space==NULL) return(ER_NOSPACE);
  4057.  
  4058.     // set the current component according the type
  4059.     switch(type) {
  4060.         case TD_OBJECT :
  4061.             space->curobjn=getObjectNode(space,index);
  4062.             if(space->curobjn==NULL) return(ER_NOINDEX);
  4063.             
  4064.             switch(space->curobjn->type) {
  4065.                 case TD_POLYMESH :
  4066.                     polymesh=(TDpolymesh *)(space->curobjn->handle);
  4067.  
  4068.                     polymesh->curmatgroupn=NULL;
  4069.                     polymesh->curpolyn=NULL;
  4070.  
  4071.                     break;
  4072.             }
  4073.  
  4074.             break;
  4075.         case TD_MATERIAL :
  4076.             if(index<1 || index>space->materials.numberOfMaterials) return(ER_NOINDEX);
  4077.  
  4078.             space->curmatn=getMaterialNode(space,index);
  4079.             if(space->curmatn==NULL) return(ER_NOINDEX);
  4080.  
  4081.             break;
  4082.         case TD_MATGROUP :
  4083.             // check the parent
  4084.             if(space->curobjn==NULL) return(ER_NOOBJECT);
  4085.             if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4086.  
  4087.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  4088.  
  4089.             // get the matgroup
  4090.             matgroupn=getMatGroupNode(polymesh,index);
  4091.             if(matgroupn==NULL) return(ER_NOINDEX);
  4092.  
  4093.             polymesh->curmatgroupn=matgroupn;
  4094.  
  4095.             break;
  4096.         case TD_POLYGON :
  4097.             // check the parent
  4098.             if(space->curobjn==NULL) return(ER_NOOBJECT);
  4099.             if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4100.  
  4101.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  4102.  
  4103.             matgroupn=polymesh->curmatgroupn;
  4104.             
  4105.             if(matgroupn==NULL) return(ER_NOMATGROUP);
  4106.  
  4107.             polyn=getPolygonNode(matgroupn,index);
  4108.             if(polyn==NULL) return(ER_NOINDEX);
  4109.  
  4110.             polymesh->curpolyn=polyn;
  4111.  
  4112.             break;
  4113.         default :
  4114.             return(ER_NOTYPE);
  4115.     }
  4116.  
  4117.     return(ER_NOERROR);
  4118. }
  4119.  
  4120. /****** td.library/tdBegin ******************************************
  4121. * 
  4122. *   NAME    
  4123. *     tdBegin -- Begin of a new child component.
  4124. * 
  4125. *   SYNOPSIS
  4126. *    error = tdBegin( spacehandle,type)
  4127. *                     D1          D2
  4128. *
  4129. *    TDerrors tdBegin
  4130. *         ( ULONG,TDenum );
  4131. *
  4132. *   FUNCTION
  4133. *    You can start to make a new child component to the
  4134. *    current component of the space.
  4135. *    In most cases for object components only.
  4136. *    Type specifies which child component.
  4137. * 
  4138. *   INPUTS
  4139. *     spacehandle     - A valid handle of a space.
  4140. *    type            - Type of the child component.
  4141. *    
  4142. *   RESULT
  4143. *     error - ER_NOERROR     if all went well.
  4144. *            ER_NOSPACE     if the handle is not valid.
  4145. *            ER_NOOBJECT    if there is no current object..
  4146. *            ER_NOMATGROUP  if there is no current material group.
  4147. *            ER_NOTYPE      if the type is not valid.
  4148. *            ER_NOMEMORY    if there is not enough memory.
  4149. *
  4150. *   EXAMPLE
  4151. *    error = tdBegin(spacehandle,TD_POLYGON);
  4152. *
  4153. *   NOTES
  4154. *    Vertices have to be added in counterclock wise direction.
  4155. *
  4156. *          v3
  4157. *         / |
  4158. *        /  |
  4159. *       /   |
  4160. *      /    |
  4161. *     /     |
  4162. *    v1--->v2
  4163. *
  4164. *   BUGS
  4165. * 
  4166. *   SEE ALSO
  4167. *     tdCurrent(),tdEnd()
  4168. * 
  4169. ******************************************************************************
  4170. *
  4171. */
  4172. TDerrors __saveds ASM tdBegin(register __d1 ULONG spacehandle,
  4173.                                 register __d2 TDenum type) {
  4174.     TDspace        *space=NULL;
  4175.     TDpolymesh        *polymesh=NULL;
  4176.     TDmatgroupnode    *matgroupnode=NULL;
  4177.     TDpolygonnode    *polynode=NULL;
  4178.  
  4179.     space=(TDspace *) spacehandle;
  4180.     if (space==NULL) return(ER_NOSPACE);
  4181.  
  4182.     // set the current component according the type
  4183.     switch(type) {
  4184.         case TD_MATGROUP :
  4185.             // check the parent
  4186.             if(space->curobjn==NULL) return(ER_NOOBJECT);
  4187.             if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4188.  
  4189.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  4190.  
  4191.             // create the new matgroup node
  4192.             matgroupnode=addMatGroupNode(polymesh,space->curmatn);
  4193.             if(matgroupnode==NULL) return(ER_NOMEMORY);
  4194.  
  4195.             // assign this matgroup node to the mesh
  4196.             polymesh->curmatgroupn=matgroupnode;
  4197.  
  4198.             break;
  4199.  
  4200.         case TD_POLYGON :
  4201.             // check the parent
  4202.             if(space->curobjn==NULL) return(ER_NOOBJECT);
  4203.             if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4204.  
  4205.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  4206.  
  4207.             // check the current matgroup
  4208.             if(polymesh->curmatgroupn==NULL) return(ER_NOMATGROUP);
  4209.  
  4210.             matgroupnode=polymesh->curmatgroupn;
  4211.  
  4212.             // Create a new polygon, add it to the internal list
  4213.             if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  4214.  
  4215.             polymesh->curpolyn=polynode;
  4216.  
  4217.             break;
  4218.         default :
  4219.             return(ER_NOTYPE);
  4220.     }
  4221.  
  4222.     return(ER_NOERROR);
  4223. }
  4224.  
  4225. /****** td.library/tdEnd ******************************************
  4226. * 
  4227. *   NAME    
  4228. *     tdEnd -- Ends a child component started with tdBegin, or
  4229. *             resets a (child) component set with tdCurrent.
  4230. * 
  4231. *   SYNOPSIS
  4232. *    error = tdEnd( spacehandle,type)
  4233. *                   D1          D2
  4234. *
  4235. *    TDerrors tdEnd
  4236. *         ( ULONG,TDenum );
  4237. *
  4238. *   FUNCTION
  4239. *    The component of the space will be reset.
  4240. *    Or the child component of a parent.
  4241. *    Type specifies which component.
  4242. * 
  4243. *   INPUTS
  4244. *     spacehandle     - A valid handle of a space.
  4245. *    type            - The component its type.
  4246. *    
  4247. *   RESULT
  4248. *     error - ER_NOERROR     if all went well.
  4249. *            ER_NOSPACE     if the handle is not valid.
  4250. *            ER_NOOBJECT    if there is no current object.
  4251. *            ER_NOTYPE      if the type is not valid.
  4252. *
  4253. *   EXAMPLE
  4254. *    error = tdEnd(spacehandle,TD_POLYGON);
  4255. *
  4256. *   NOTES
  4257. *
  4258. *   BUGS
  4259. * 
  4260. *   SEE ALSO
  4261. *     tdBegin(),tdCurrent()
  4262. * 
  4263. ******************************************************************************
  4264. *
  4265. */
  4266. TDerrors __saveds ASM tdEnd(register __d1 ULONG spacehandle,
  4267.                             register __d2 TDenum type) {
  4268.     TDspace        *space=NULL;
  4269.     TDpolymesh        *polymesh=NULL;
  4270.  
  4271.     space=(TDspace *) spacehandle;
  4272.     if (space==NULL) return(ER_NOSPACE);
  4273.  
  4274.     // reset the current component according the type
  4275.     switch(type) {
  4276.         case TD_OBJECT :
  4277.             space->curobjn=NULL;
  4278.  
  4279.             break;
  4280.         case TD_MATERIAL :
  4281.             space->curmatn=NULL;
  4282.  
  4283.             break;
  4284.         case TD_MATGROUP :
  4285.             // check the parent
  4286.             if(space->curobjn==NULL) return(ER_NOOBJECT);
  4287.             if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4288.  
  4289.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  4290.  
  4291.             polymesh->curmatgroupn=NULL;
  4292.  
  4293.             // no matgroup => no polygon
  4294.             polymesh->curpolyn=NULL;
  4295.  
  4296.             break;
  4297.         case TD_POLYGON :
  4298.             // check the parent
  4299.             if(space->curobjn==NULL) return(ER_NOOBJECT);
  4300.             if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4301.  
  4302.             polymesh=(TDpolymesh *)(space->curobjn->handle);
  4303.  
  4304.             polymesh->curpolyn=NULL;
  4305.  
  4306.             break;
  4307.         default :
  4308.             return(ER_NOTYPE);
  4309.     }
  4310.  
  4311.     return(ER_NOERROR);
  4312. }
  4313.  
  4314. /****** td.library/tdVertexAdd3f *************************************************
  4315. * 
  4316. *   NAME    
  4317. *     tdVertexAdd3f -- Add a new vertex to the current object its
  4318. *                     vertex list or to the current polygon,
  4319. *                     this according the CTM.
  4320. *
  4321. *   SYNOPSIS
  4322. *    error = tdVertexAdd3f( spacehandle,x, y, z )
  4323. *                           D1          D2 D3 D4
  4324. *
  4325. *    TDerrors tdVertexAdd3f
  4326. *         ( ULONG,TDfloat,TDfloat,TDfloat );
  4327. *
  4328. *   FUNCTION
  4329. *    A new vertex will be added to the current object its vertex list.
  4330. *   If tdBegin or tdCurrent was called before it will be assigned
  4331. *    to the current polygon, else it will only be added to the object,
  4332. *    binding to a polygon can be made later.
  4333. *   The index of the new vertex will be the new number of vertices
  4334. *    count.
  4335. * 
  4336. *   INPUTS
  4337. *     spacehandle   - A valid handle of a space.
  4338. *    x,y,z         - The coordinates of the new vertex.
  4339. *    
  4340. *   RESULT
  4341. *     error - ER_NOERROR    if all went well.
  4342. *            ER_NOSPACE    if the handle is not valid.
  4343. *            ER_NOOBJECT   if there is no current object.
  4344. *            ER_NOMEMORY   if there is not enough memory. 
  4345. * 
  4346. *   EXAMPLE
  4347. *    error = tdVertexAdd3f(spacehandle,1.0,2.0,3.0);
  4348. *
  4349. *   NOTES
  4350. *    Vertices have to be added in counterclock wise direction.
  4351. *
  4352. *          v3
  4353. *         / |
  4354. *        /  |
  4355. *       /   |
  4356. *      /    |
  4357. *     /     |
  4358. *    v1--->v2
  4359. *
  4360. *   BUGS
  4361. * 
  4362. *   SEE ALSO
  4363. *     tdVertexGet(),
  4364. *    tdVertexIndexGet(),tdVertexAssign()
  4365. * 
  4366. ******************************************************************************
  4367. *
  4368. */
  4369. TDerrors __saveds ASM tdVertexAdd3f(register __d1 ULONG spacehandle,
  4370.                                     register __d2 TDfloat x,
  4371.                                     register __d3 TDfloat y,
  4372.                                     register __d4 TDfloat z) {
  4373.                                 
  4374.     TDspace        *space=NULL;
  4375.     TDpolymesh        *mesh=NULL;
  4376.     TDvectord        vertex;
  4377.     ULONG            vindex;
  4378.  
  4379.     vertex.x=x,vertex.y=y,vertex.z=z;
  4380.     
  4381.     space=(TDspace *) spacehandle;
  4382.     if (space==NULL) return(ER_NOSPACE);
  4383.  
  4384.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4385.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4386.  
  4387.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4388.  
  4389.     if((vindex=addVertex(mesh,space->ctm,vertex))==0) return(ER_NOMEMORY);
  4390.  
  4391.     // check if we have to assign it to a current polygon
  4392.     if(mesh->curpolyn!=NULL) {
  4393.         if(assignVertex(mesh,mesh->curmatgroupn,mesh->curpolyn,vindex)==0) return(ER_NOMEMORY);
  4394.     }
  4395.  
  4396.     return(ER_NOERROR);
  4397. }
  4398.  
  4399. /****** td.library/tdVertexGet3d *************************************************
  4400. * 
  4401. *   NAME    
  4402. *     tdVertexGet3d -- Get a vertex of the current object its vertex list. If a
  4403. *                     current polygon is set the vertexindex is assumed
  4404. *                     to be out of the polygon and you will get the vertex
  4405. *                     of the polygon.
  4406. *
  4407. *   SYNOPSIS
  4408. *    error = tdVertexGet3d( spacehandle,vertexindex,x, y, z )
  4409. *                           D1          D2          D3 D4 D5
  4410. *
  4411. *    TDerrors tdVertexGet3d
  4412. *         ( ULONG,ULONG,TDdouble *,TDdouble *,TDdouble * );
  4413. *
  4414. *   FUNCTION
  4415. *    The vertex of the current object found with vertexindex
  4416. *    will be returned in the passed 3 coordinate variables.
  4417. *    Or if a current polygon is set you will get
  4418. *    the vertex of the polygon.
  4419. * 
  4420. *   INPUTS
  4421. *     spacehandle  - A valid handle of a space.
  4422. *    vertexindex  - A valid index of a vertex.
  4423. *    x,y,z        - The double variables which will contain 
  4424. *                   the coordinates of the vertex.
  4425. *    
  4426. *   RESULT
  4427. *     error - ER_NOERROR    if all went well.
  4428. *            ER_NOSPACE    if the handle is not valid.
  4429. *            ER_NOOBJECT   if there is no current object.
  4430. *            ER_NOVERTEX   if the index is not valid.
  4431. * 
  4432. *   EXAMPLE
  4433. *    error = tdVertexGet3d(spacehandle,vertexindex,&x,&y,&z);
  4434. *
  4435. *   NOTES
  4436. *
  4437. *   BUGS
  4438. * 
  4439. *   SEE ALSO
  4440. *     tdVertexAdd(),
  4441. *    tdVertexIndexGet(),tdVertexAssign()
  4442. * 
  4443. ******************************************************************************
  4444. *
  4445. */
  4446. TDerrors __saveds ASM tdVertexGet3d(register __d1 ULONG spacehandle,
  4447.                                     register __d2 ULONG vertexindex,
  4448.                                     register __d3 TDdouble *x,
  4449.                                     register __d4 TDdouble *y,
  4450.                                     register __d5 TDdouble *z) {
  4451.                                 
  4452.     TDspace    *space=NULL;
  4453.     TDpolymesh    *mesh=NULL;
  4454.     TDvectord    *vertex=NULL;
  4455.     ULONG        vindex;
  4456.       
  4457.     space=(TDspace *) spacehandle;
  4458.     if (space==NULL) return(ER_NOSPACE);
  4459.  
  4460.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4461.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4462.  
  4463.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4464.     // check if the mesh its vertex or the one of the current polygon
  4465.     if(mesh->curpolyn==NULL) {
  4466.         vindex=vertexindex;
  4467.     } else {
  4468.         if(vertexindex<1 || vertexindex>mesh->curpolyn->numberOfVertices) return(ER_NOVERTEX);
  4469.         // internal index = - 1
  4470.         vindex=mesh->curpolyn->varray[vertexindex-1];
  4471.     }
  4472.  
  4473.     vertex=getVertex(mesh,vindex);
  4474.     if(vertex==NULL) return(ER_NOVERTEX);
  4475.  
  4476.     (*x)=vertex->x;
  4477.     (*y)=vertex->y;
  4478.     (*z)=vertex->z;
  4479.  
  4480.     return(ER_NOERROR);
  4481. }
  4482.  
  4483. /****** td.library/tdVertexGet3f *************************************************
  4484. * 
  4485. *   NAME    
  4486. *     tdVertexGet3f -- Get a vertex of the current object its vertex list. If a
  4487. *                     current polygon is set the vertexindex is assumed
  4488. *                     to be out of the polygon and you will get the vertex
  4489. *                     of the polygon.
  4490. *
  4491. *   SYNOPSIS
  4492. *    error = tdVertexGet3f( spacehandle,vertexindex,x, y, z )
  4493. *                           D1          D2          D3 D4 D5
  4494. *
  4495. *    TDerrors tdVertexGet3f
  4496. *         ( ULONG,ULONG,TDfloat *,TDfloat *,TDfloat * );
  4497. *
  4498. *   FUNCTION
  4499. *    The vertex of the current object found with vertexindex
  4500. *    will be returned in the passed 3 coordinate variables.
  4501. *    Or if a current polygon is set you will get
  4502. *    the vertex of the polygon.
  4503. * 
  4504. *   INPUTS
  4505. *     spacehandle  - A valid handle of a space.
  4506. *    vertexindex  - A valid index of a vertex.
  4507. *    x,y,z        - The float variables which will contain 
  4508. *                   the coordinates of the vertex.
  4509. *    
  4510. *   RESULT
  4511. *     error - ER_NOERROR    if all went well.
  4512. *            ER_NOSPACE    if the handle is not valid.
  4513. *            ER_NOOBJECT   if there is no current object.
  4514. *            ER_NOVERTEX   if the index is not valid.
  4515. * 
  4516. *   EXAMPLE
  4517. *    error = tdVertexGet3f(spacehandle,vertexindex,&x,&y,&z);
  4518. *
  4519. *   NOTES
  4520. *
  4521. *   BUGS
  4522. * 
  4523. *   SEE ALSO
  4524. *     tdVertexAdd(),
  4525. *    tdVertexIndexGet(),tdVertexAssign()
  4526. * 
  4527. ******************************************************************************
  4528. *
  4529. */
  4530. TDerrors __saveds ASM tdVertexGet3f(register __d1 ULONG spacehandle,
  4531.                                     register __d2 ULONG vertexindex,
  4532.                                     register __d3 TDfloat *x,
  4533.                                     register __d4 TDfloat *y,
  4534.                                     register __d5 TDfloat *z) {
  4535.                                 
  4536.     TDspace    *space=NULL;
  4537.     TDpolymesh    *mesh=NULL;
  4538.     TDvectord    *vertex=NULL;
  4539.     ULONG        vindex;
  4540.       
  4541.     space=(TDspace *) spacehandle;
  4542.     if (space==NULL) return(ER_NOSPACE);
  4543.  
  4544.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4545.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4546.  
  4547.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4548.     // check if the mesh its vertex or the one of the current polygon
  4549.     if(mesh->curpolyn==NULL) {
  4550.         vindex=vertexindex;
  4551.     } else {
  4552.         if(vertexindex<1 || vertexindex>mesh->curpolyn->numberOfVertices) return(ER_NOVERTEX);
  4553.         // internal index = - 1
  4554.         vindex=mesh->curpolyn->varray[vertexindex-1];
  4555.     }
  4556.  
  4557.     vertex=getVertex(mesh,vindex);
  4558.     if(vertex==NULL) return(ER_NOVERTEX);
  4559.  
  4560.     (*x)=vertex->x;
  4561.     (*y)=vertex->y;
  4562.     (*z)=vertex->z;
  4563.  
  4564.     return(ER_NOERROR);
  4565. }
  4566.  
  4567. /****** td.library/tdVertexAdddv *************************************************
  4568. * 
  4569. *   NAME    
  4570. *     tdVertexAdddv -- Add a new vertex to the current object its
  4571. *                     vertex list or to the current polygon,
  4572. *                     this according the CTM.
  4573. *
  4574. *   SYNOPSIS
  4575. *    error = tdVertexAdddv( spacehandle,vertex )
  4576. *                           D1           A0
  4577. *
  4578. *    TDerrors tdVertexAdddv
  4579. *         ( ULONG,TDvectord * );
  4580. *
  4581. *   FUNCTION
  4582. *    A new vertex will be added to the current object its vertex list.
  4583. *    If tdBegin or tdCurrent was called before, it will be assigned
  4584. *    to the current polygon, else it will only be added to the object,
  4585. *    binding to a polygon can be made later.
  4586. *    The index of the new vertex will be the new number of vertices
  4587. *    count.
  4588. * 
  4589. *   INPUTS
  4590. *     spacehandle  - A valid handle of a space.
  4591. *    vertex       - Pointer to a vector structure which contains the
  4592. *                   coordinates of the new vertex.
  4593. *    
  4594. *   RESULT
  4595. *     error - ER_NOERROR    if all went well.
  4596. *            ER_NOSPACE    if the handle is not valid.
  4597. *            ER_NOOBJECT   if there is no current object.
  4598. *            ER_NOMEMORY   if there is not enough memory. 
  4599. * 
  4600. *   EXAMPLE
  4601. *    error = tdVertexAdddv(spacehandle,&myvertex);
  4602. *
  4603. *   NOTES
  4604. *    Vertices have to be added in counterclock wise direction.
  4605. *
  4606. *          v3
  4607. *         / |
  4608. *        /  |
  4609. *       /   |
  4610. *      /    |
  4611. *     /     |
  4612. *    v1--->v2
  4613. *
  4614. *   BUGS
  4615. * 
  4616. *   SEE ALSO
  4617. *     tdVertexGet(),
  4618. *    tdVertexIndexGet(),tdVertexAssign()
  4619. * 
  4620. ******************************************************************************
  4621. *
  4622. */
  4623. TDerrors __saveds ASM tdVertexAdddv(register __d1 ULONG spacehandle,
  4624.                                     register __a0 TDvectord *vertex) {
  4625.  
  4626.  
  4627.     TDspace        *space=NULL;
  4628.     TDpolymesh        *mesh=NULL;
  4629.     TDvectord        *mvertex=NULL;
  4630.     ULONG            vindex;
  4631.  
  4632.     mvertex=vertex;
  4633.     
  4634.     space=(TDspace *) spacehandle;
  4635.     if (space==NULL) return(ER_NOSPACE);
  4636.  
  4637.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4638.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4639.  
  4640.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4641.  
  4642.     if((vindex=addVertex(mesh,space->ctm,(*mvertex)))==0) return(ER_NOMEMORY);
  4643.  
  4644.     // check if we have to assign it to a current polygon
  4645.     if(mesh->curpolyn!=NULL) {
  4646.         if(assignVertex(mesh,mesh->curmatgroupn,mesh->curpolyn,vindex)==0) return(ER_NOMEMORY);
  4647.     }
  4648.  
  4649.     return(ER_NOERROR);
  4650. }
  4651.  
  4652. /****** td.library/tdVertexAddfv *************************************************
  4653. * 
  4654. *   NAME    
  4655. *     tdVertexAddfv -- Add a new vertex to the current object its
  4656. *                     vertex list or to the current polygon,
  4657. *                     this according the CTM.
  4658. *
  4659. *   SYNOPSIS
  4660. *    error = tdVertexAddfv( spacehandle,vertex )
  4661. *                           D1           A0
  4662. *
  4663. *    TDerrors tdVertexAddfv
  4664. *         ( ULONG,TDvectorf * );
  4665. *
  4666. *   FUNCTION
  4667. *    A new vertex will be added to the current object its vertex list.
  4668. *    If tdBegin or tdCurrent was called before, it will be assigned
  4669. *    to the current polygon, else it will only be added to the object,
  4670. *    binding to a polygon can be made later.
  4671. *    The index of the new vertex will be the new number of vertices
  4672. *    count.
  4673. * 
  4674. *   INPUTS
  4675. *     spacehandle  - A valid handle of a space.
  4676. *    vertex       - Pointer to a vector structure which contains the
  4677. *                   coordinates of the new vertex.
  4678. *    
  4679. *   RESULT
  4680. *     error - ER_NOERROR    if all went well.
  4681. *            ER_NOSPACE    if the handle is not valid.
  4682. *            ER_NOOBJECT   if there is no current object.
  4683. *            ER_NOMEMORY   if there is not enough memory. 
  4684. * 
  4685. *   EXAMPLE
  4686. *    error = tdVertexAddfv(spacehandle,&myvertex);
  4687. *
  4688. *   NOTES
  4689. *    Vertices have to be added in counterclock wise direction.
  4690. *
  4691. *          v3
  4692. *         / |
  4693. *        /  |
  4694. *       /   |
  4695. *      /    |
  4696. *     /     |
  4697. *    v1--->v2
  4698. *
  4699. *   BUGS
  4700. * 
  4701. *   SEE ALSO
  4702. *     tdVertexGet(),
  4703. *    tdVertexIndexGet(),tdVertexAssign()
  4704. * 
  4705. ******************************************************************************
  4706. *
  4707. */
  4708. TDerrors __saveds ASM tdVertexAddfv(register __d1 ULONG spacehandle,
  4709.                                     register __a0 TDvectorf *vertex) {
  4710.  
  4711.  
  4712.     TDspace        *space=NULL;
  4713.     TDpolymesh        *mesh=NULL;
  4714.     TDvectord        mvertex;
  4715.     ULONG            vindex;
  4716.  
  4717.     mvertex.x=vertex->x;
  4718.     mvertex.y=vertex->y;
  4719.     mvertex.z=vertex->z;
  4720.  
  4721.     space=(TDspace *) spacehandle;
  4722.     if (space==NULL) return(ER_NOSPACE);
  4723.  
  4724.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4725.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4726.  
  4727.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4728.  
  4729.     if((vindex=addVertex(mesh,space->ctm,mvertex))==0) return(ER_NOMEMORY);
  4730.  
  4731.     // check if we have to assign it to a current polygon
  4732.     if(mesh->curpolyn!=NULL) {
  4733.         if(assignVertex(mesh,mesh->curmatgroupn,mesh->curpolyn,vindex)==0) return(ER_NOMEMORY);
  4734.     }
  4735.  
  4736.     return(ER_NOERROR);
  4737. }
  4738.  
  4739. /****** td.library/tdVertexAdd3da *************************************************
  4740. * 
  4741. *   NAME    
  4742. *     tdVertexAdd3da -- Add a new vertex to the current object its
  4743. *                      vertex list or to the current polygon,
  4744. *                      this according the CTM.
  4745. *   SYNOPSIS
  4746. *    error = tdVertexAdd3da( spacehandle,array )
  4747. *                            D1           A0
  4748. *
  4749. *    TDerrors tdVertexAdd3da
  4750. *         ( ULONG,TDdouble [3] );
  4751. *
  4752. *   FUNCTION
  4753. *    A new vertex will be added to the current object its vertex list.
  4754. *    If tdBegin or tdCurrent was called before, it will be assigned
  4755. *    to the current polygon, else it will only be added to the object,
  4756. *    binding to a polygon can be made later.
  4757. *    The index of the new vertex will be the new number of vertices
  4758. *    count.
  4759. * 
  4760. *   INPUTS
  4761. *     spacehandle  - A valid handle of a space.
  4762. *    array        - A double array which contains the coordinates
  4763. *                   of the new vertex.
  4764. *    
  4765. *   RESULT
  4766. *     error - ER_NOERROR    if all went well.
  4767. *            ER_NOSPACE    if the handle is not valid.
  4768. *            ER_NOOBJECT   if there is no current object.
  4769. *            ER_NOMEMORY   if there is not enough memory. 
  4770. * 
  4771. *   EXAMPLE
  4772. *    error = tdVertexAdd3da(spacehandle,myvertex);
  4773. *
  4774. *   NOTES
  4775. *    Vertices have to be added in counterclock wise direction.
  4776. *
  4777. *          v3
  4778. *         / |
  4779. *        /  |
  4780. *       /   |
  4781. *      /    |
  4782. *     /     |
  4783. *    v1--->v2
  4784. *
  4785. *   BUGS
  4786. * 
  4787. *   SEE ALSO
  4788. *     tdVertexGet(),
  4789. *    tdVertexIndexGet(),tdVertexAssign()
  4790. * 
  4791. ******************************************************************************
  4792. *
  4793. */
  4794. TDerrors __saveds ASM tdVertexAdd3da(register __d1 ULONG spacehandle,
  4795.                                     register __a0 TDdouble array[3]) {
  4796.  
  4797.     TDspace        *space=NULL;
  4798.     TDpolymesh        *mesh=NULL;
  4799.     TDvectord        mvertex;
  4800.     ULONG            vindex;
  4801.  
  4802.     mvertex.x=array[0];
  4803.     mvertex.y=array[1];
  4804.     mvertex.z=array[2];
  4805.  
  4806.     space=(TDspace *) spacehandle;
  4807.     if (space==NULL) return(ER_NOSPACE);
  4808.  
  4809.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4810.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4811.  
  4812.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4813.  
  4814.     if((vindex=addVertex(mesh,space->ctm,mvertex))==0) return(ER_NOMEMORY);
  4815.  
  4816.     // check if we have to assign it to a current polygon
  4817.     if(mesh->curpolyn!=NULL) {
  4818.         if(assignVertex(mesh,mesh->curmatgroupn,mesh->curpolyn,vindex)==0) return(ER_NOMEMORY);
  4819.     }
  4820.  
  4821.     return(ER_NOERROR);
  4822. }
  4823.  
  4824. /****** td.library/tdVertexAdd3fa *************************************************
  4825. * 
  4826. *   NAME    
  4827. *     tdVertexAdd3fa -- Add a new vertex to the current object its
  4828. *                      vertex list or to the current polygon,
  4829. *                      this according the CTM.
  4830. *   SYNOPSIS
  4831. *    error = tdVertexAdd3fa( spacehandle,array )
  4832. *                            D1           A0
  4833. *
  4834. *    TDerrors tdVertexAdd3fa
  4835. *         ( ULONG,TDfloat [3] );
  4836. *
  4837. *   FUNCTION
  4838. *    A new vertex will µbe added to the current object its vertex list.
  4839. *    If tdBegin or tdCurrent was called before, it will be assigned
  4840. *    to the current polygon, else it will only be added to the object,
  4841. *    binding to a polygon can be made later.
  4842. *    The index of the new vertex will be the new number of vertices
  4843. *    count.
  4844. * 
  4845. *   INPUTS
  4846. *     spacehandle  - A valid handle of a space.
  4847. *    array        - A float array which contains the coordinates
  4848. *                   of the new vertex.
  4849. *    
  4850. *   RESULT
  4851. *     error - ER_NOERROR    if all went well.
  4852. *            ER_NOSPACE    if the handle is not valid.
  4853. *            ER_NOOBJECT   if there is no current object.
  4854. *            ER_NOMEMORY   if there is not enough memory. 
  4855. * 
  4856. *   EXAMPLE
  4857. *    error = tdVertexAdd3fa(spacehandle,myvertex);
  4858. *
  4859. *   NOTES
  4860. *    Vertices have to be added in counterclock wise direction.
  4861. *
  4862. *          v3
  4863. *         / |
  4864. *        /  |
  4865. *       /   |
  4866. *      /    |
  4867. *     /     |
  4868. *    v1--->v2
  4869. *
  4870. *   BUGS
  4871. * 
  4872. *   SEE ALSO
  4873. *     tdVertexGet(),
  4874. *    tdVertexIndexGet(),tdVertexAssign()
  4875. * 
  4876. ******************************************************************************
  4877. *
  4878. */
  4879. TDerrors __saveds ASM tdVertexAdd3fa(register __d1 ULONG spacehandle,
  4880.                                     register __a0 TDfloat array[3]) {
  4881.  
  4882.     TDspace        *space=NULL;
  4883.     TDpolymesh        *mesh=NULL;
  4884.     TDvectord        mvertex;
  4885.     ULONG            vindex;
  4886.  
  4887.     mvertex.x=array[0];
  4888.     mvertex.y=array[1];
  4889.     mvertex.z=array[2];
  4890.  
  4891.     space=(TDspace *) spacehandle;
  4892.     if (space==NULL) return(ER_NOSPACE);
  4893.  
  4894.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4895.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4896.  
  4897.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4898.  
  4899.     if((vindex=addVertex(mesh,space->ctm,mvertex))==0) return(ER_NOMEMORY);
  4900.  
  4901.     // check if we have to assign it to a current polygon
  4902.     if(mesh->curpolyn!=NULL) {
  4903.         if(assignVertex(mesh,mesh->curmatgroupn,mesh->curpolyn,vindex)==0) return(ER_NOMEMORY);
  4904.     }
  4905.  
  4906.     return(ER_NOERROR);
  4907. }
  4908.  
  4909. /****** td.library/tdVertexGetdv *************************************************
  4910. * 
  4911. *   NAME    
  4912. *     tdVertexGetdv -- Get a vertex of the current object its vertex list. If a
  4913. *                     current polygon is set the vertexindex is assumed
  4914. *                     to be out of the polygon and you will get the vertex
  4915. *                     of the polygon.
  4916. *
  4917. *   SYNOPSIS
  4918. *    error = tdVertexGetdv( spacehandle,vertexindex,vertex )
  4919. *                           D1          D2           A0
  4920. *
  4921. *    TDerrors tdVertexGetdv
  4922. *         ( ULONG,ULONG,TDvectord * );
  4923. *
  4924. *   FUNCTION
  4925. *    The vertex of the current object found with vertexindex
  4926. *    will be returned in the passed vector structure.
  4927. *    Or if a current polygon is set you will get
  4928. *    the vertex of the polygon.
  4929. * 
  4930. *   INPUTS
  4931. *     spacehandle  - A valid handle of a space.
  4932. *    vertexindex  - A valid handle of a vertex
  4933. *    vertex       - Pointer to a vector structure which will contain
  4934. *                   the coordinates of the vertex.
  4935. *    
  4936. *   RESULT
  4937. *     error - ER_NOERROR    if all went well.
  4938. *            ER_NOSPACE    if the handle is not valid.
  4939. *            ER_NOOBJECT   if there is no current object.
  4940. *            ER_NOVERTEX   if the index is not valid.
  4941. * 
  4942. *   EXAMPLE
  4943. *    error = tdVertexGetdv(spacehandle,67,&myvertex);
  4944. *
  4945. *   NOTES
  4946. *
  4947. *   BUGS
  4948. * 
  4949. *   SEE ALSO
  4950. *     tdVertexAdd(),
  4951. *    tdVertexIndexGet(),tdVertexAssign()
  4952. * 
  4953. ******************************************************************************
  4954. *
  4955. */
  4956. TDerrors __saveds ASM tdVertexGetdv(register __d1 ULONG spacehandle,
  4957.                                     register __d2 ULONG vertexindex,
  4958.                                     register __a0 TDvectord *vertex) {
  4959.  
  4960.     TDspace    *space=NULL;
  4961.     TDpolymesh    *mesh=NULL;
  4962.     TDvectord    *mvertex=NULL;
  4963.     ULONG        vindex;
  4964.       
  4965.     space=(TDspace *) spacehandle;
  4966.     if (space==NULL) return(ER_NOSPACE);
  4967.  
  4968.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  4969.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  4970.  
  4971.     mesh=(TDpolymesh *)(space->curobjn->handle);
  4972.     // check if the mesh its vertex or the one of the current polygon
  4973.     if(mesh->curpolyn==NULL) {
  4974.         vindex=vertexindex;
  4975.     } else {
  4976.         if(vertexindex<1 || vertexindex>mesh->curpolyn->numberOfVertices) return(ER_NOVERTEX);
  4977.         // internal index = - 1
  4978.         vindex=mesh->curpolyn->varray[vertexindex-1];
  4979.     }
  4980.  
  4981.     mvertex=getVertex(mesh,vindex);
  4982.     if(mvertex==NULL) return(ER_NOVERTEX);
  4983.  
  4984.     vertex->x=mvertex->x;
  4985.     vertex->y=mvertex->y;
  4986.     vertex->z=mvertex->z;
  4987.  
  4988.     return(ER_NOERROR);
  4989. }
  4990.  
  4991. /****** td.library/tdVertexGetfv *************************************************
  4992. * 
  4993. *   NAME    
  4994. *     tdVertexGetfv -- Get a vertex of the current object its vertex list. If a
  4995. *                     current polygon is set the vertexindex is assumed
  4996. *                     to be out of the polygon and you will get the vertex
  4997. *                     of the polygon.
  4998. *
  4999. *   SYNOPSIS
  5000. *    error = tdVertexGetfv( spacehandle,vertexindex,vertex )
  5001. *                           D1          D2           A0
  5002. *
  5003. *    TDerrors tdVertexGetfv
  5004. *         ( ULONG,ULONG,TDvectorf * );
  5005. *
  5006. *   FUNCTION
  5007. *    The vertex of the current object found with vertexindex
  5008. *    will be returned in the passed vector structure.
  5009. *    Or if a current polygon is set you will get
  5010. *    the vertex of the polygon.
  5011. * 
  5012. *   INPUTS
  5013. *     spacehandle  - A valid handle of a space.
  5014. *    vertexindex  - A valid handle of a vertex
  5015. *    vertex       - Pointer to a vector structure which will contain
  5016. *                   the coordinates of the vertex.
  5017. *    
  5018. *   RESULT
  5019. *     error - ER_NOERROR    if all went well.
  5020. *            ER_NOSPACE    if the handle is not valid.
  5021. *            ER_NOOBJECT   if there is no current object.
  5022. *            ER_NOVERTEX   if the index is not valid.
  5023. * 
  5024. *   EXAMPLE
  5025. *    error = tdVertexGetfv(spacehandle,32,&myvertex);
  5026. *
  5027. *   NOTES
  5028. *
  5029. *   BUGS
  5030. * 
  5031. *   SEE ALSO
  5032. *     tdVertexAdd(),
  5033. *    tdVertexIndexGet(),tdVertexAssign()
  5034. * 
  5035. ******************************************************************************
  5036. *
  5037. */
  5038. TDerrors __saveds ASM tdVertexGetfv(register __d1 ULONG spacehandle,
  5039.                                     register __d2 ULONG vertexindex,
  5040.                                     register __a0 TDvectorf *vertex) {
  5041.  
  5042.     TDspace    *space=NULL;
  5043.     TDpolymesh    *mesh=NULL;
  5044.     TDvectord    *mvertex=NULL;
  5045.     ULONG        vindex;
  5046.       
  5047.     space=(TDspace *) spacehandle;
  5048.     if (space==NULL) return(ER_NOSPACE);
  5049.  
  5050.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5051.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5052.  
  5053.     mesh=(TDpolymesh *)(space->curobjn->handle);
  5054.     // check if the mesh its vertex or the one of the current polygon
  5055.     if(mesh->curpolyn==NULL) {
  5056.         vindex=vertexindex;
  5057.     } else {
  5058.         if(vertexindex<1 || vertexindex>mesh->curpolyn->numberOfVertices) return(ER_NOVERTEX);
  5059.         // internal index = - 1
  5060.         vindex=mesh->curpolyn->varray[vertexindex-1];
  5061.     }
  5062.  
  5063.     mvertex=getVertex(mesh,vindex);
  5064.     if(mvertex==NULL) return(ER_NOVERTEX);
  5065.  
  5066.     vertex->x=mvertex->x;
  5067.     vertex->y=mvertex->y;
  5068.     vertex->z=mvertex->z;
  5069.  
  5070.     return(ER_NOERROR);
  5071. }
  5072.  
  5073. /****** td.library/tdVertexGet3da *************************************************
  5074. * 
  5075. *   NAME    
  5076. *     tdVertexGet3da -- Get a vertex of the current object its vertex list. If a
  5077. *                      current polygon is set the vertexindex is assumed
  5078. *                      to be out of the polygon and you will get the vertex
  5079. *                      of the polygon.
  5080. *
  5081. *   SYNOPSIS
  5082. *    error = tdVertexGet3da( spacehandle,vertexindex,array )
  5083. *                            D1          D2           A0
  5084. *
  5085. *    TDerrors tdVertexGet3da
  5086. *         ( ULONG,ULONG,TDdouble [3] );
  5087. *
  5088. *   FUNCTION
  5089. *    The vertex of the current object found with vertexindex
  5090. *    will be returned in the passed double array.
  5091. *    Or if a current polygon is set you will get
  5092. *    the vertex of the polygon.
  5093. * 
  5094. *   INPUTS
  5095. *     spacehandle  - A valid handle of a space.
  5096. *    vertexindex  - A valid handle of a vertex
  5097. *    array        - A correct sized double array which will contain
  5098. *                   the coordinates of the vertex.
  5099. *    
  5100. *   RESULT
  5101. *     error - ER_NOERROR    if all went well.
  5102. *            ER_NOSPACE    if the handle is not valid.
  5103. *            ER_NOOBJECT   if there is no current object.
  5104. *            ER_NOVERTEX   if the index is not valid.
  5105. * 
  5106. *   EXAMPLE
  5107. *    error = tdVertexGet3da(spacehandle,17,array);
  5108. *
  5109. *   NOTES
  5110. *
  5111. *   BUGS
  5112. * 
  5113. *   SEE ALSO
  5114. *     tdVertexAdd(),
  5115. *    tdVertexIndexGet(),tdVertexAssign()
  5116. * 
  5117. ******************************************************************************
  5118. *
  5119. */
  5120. TDerrors __saveds ASM tdVertexGet3da(register __d1 ULONG spacehandle,
  5121.                                     register __d2 ULONG vertexindex,
  5122.                                     register __a0 TDdouble array[3]) {
  5123.  
  5124.     TDspace    *space=NULL;
  5125.     TDpolymesh    *mesh=NULL;
  5126.     TDvectord    *mvertex=NULL;
  5127.     TDdouble    *marray=NULL;
  5128.     ULONG        vindex;
  5129.  
  5130.     // make a copy of the array, a0 is a scratch register
  5131.     marray=array;
  5132.       
  5133.     space=(TDspace *) spacehandle;
  5134.     if (space==NULL) return(ER_NOSPACE);
  5135.  
  5136.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5137.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5138.  
  5139.     mesh=(TDpolymesh *)(space->curobjn->handle);
  5140.     // check if the mesh its vertex or the one of the current polygon
  5141.     if(mesh->curpolyn==NULL) {
  5142.         vindex=vertexindex;
  5143.     } else {
  5144.         if(vertexindex<1 || vertexindex>mesh->curpolyn->numberOfVertices) return(ER_NOVERTEX);
  5145.         // internal index = - 1
  5146.         vindex=mesh->curpolyn->varray[vertexindex-1];
  5147.     }
  5148.  
  5149.     mvertex=getVertex(mesh,vindex);
  5150.     if(mvertex==NULL) return(ER_NOVERTEX);
  5151.  
  5152.     marray[0]=mvertex->x;
  5153.     marray[1]=mvertex->y;
  5154.     marray[2]=mvertex->z;
  5155.  
  5156.     return(ER_NOERROR);
  5157. }
  5158.  
  5159. /****** td.library/tdVertexGet3fa *************************************************
  5160. * 
  5161. *   NAME    
  5162. *     tdVertexGet3fa -- Get a vertex of the current object its vertex list. If a
  5163. *                      current polygon is set the vertexindex is assumed
  5164. *                      to be out of the polygon and you will get the vertex
  5165. *                      of the polygon.
  5166. *
  5167. *   SYNOPSIS
  5168. *    error = tdVertexGet3fa( spacehandle,vertexindex,array )
  5169. *                            D1          D2           A0
  5170. *
  5171. *    TDerrors tdVertexGet3fa
  5172. *         ( ULONG,ULONG,TDfloat [3] );
  5173. *
  5174. *   FUNCTION
  5175. *    The vertex of the current object found with vertexindex
  5176. *    will be returned in the passed float array.
  5177. *    Or if a current polygon is set you will get
  5178. *    the vertex of the polygon.
  5179. * 
  5180. *   INPUTS
  5181. *     spacehandle  - A valid handle of a space.
  5182. *    vertexindex  - A valid handle of a vertex
  5183. *    array        - A correct sized float array which will contain
  5184. *                   the coordinates of the vertex.
  5185. *    
  5186. *   RESULT
  5187. *     error - ER_NOERROR    if all went well.
  5188. *            ER_NOSPACE    if the handle is not valid.
  5189. *            ER_NOOBJECT   if there is no current object.
  5190. *            ER_NOVERTEX   if the index is not valid.
  5191. * 
  5192. *   EXAMPLE
  5193. *    error = tdVertexGet3fa(spacehandle,17,array);
  5194. *
  5195. *   NOTES
  5196. *
  5197. *   BUGS
  5198. * 
  5199. *   SEE ALSO
  5200. *     tdVertexAdd(),
  5201. *    tdVertexIndexGet(),tdVertexAssign()
  5202. * 
  5203. ******************************************************************************
  5204. *
  5205. */
  5206. TDerrors __saveds ASM tdVertexGet3fa(register __d1 ULONG spacehandle,
  5207.                                     register __d2 ULONG vertexindex,
  5208.                                     register __a0 TDfloat array[3]) {
  5209.  
  5210.     TDspace    *space=NULL;
  5211.     TDpolymesh    *mesh=NULL;
  5212.     TDvectord    *mvertex=NULL;
  5213.     TDfloat    *marray=NULL;
  5214.     ULONG        vindex;
  5215.  
  5216.     // make a copy of the array, a0 is a scratch register
  5217.     marray=array;
  5218.       
  5219.     space=(TDspace *) spacehandle;
  5220.     if (space==NULL) return(ER_NOSPACE);
  5221.  
  5222.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5223.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5224.  
  5225.     mesh=(TDpolymesh *)(space->curobjn->handle);
  5226.     // check if the mesh its vertex or the one of the current polygon
  5227.     if(mesh->curpolyn==NULL) {
  5228.         vindex=vertexindex;
  5229.     } else {
  5230.         if(vertexindex<1 || vertexindex>mesh->curpolyn->numberOfVertices) return(ER_NOVERTEX);
  5231.         // internal index = - 1
  5232.         vindex=mesh->curpolyn->varray[vertexindex-1];
  5233.     }
  5234.  
  5235.     mvertex=getVertex(mesh,vindex);
  5236.     if(mvertex==NULL) return(ER_NOVERTEX);
  5237.  
  5238.     marray[0]=mvertex->x;
  5239.     marray[1]=mvertex->y;
  5240.     marray[2]=mvertex->z;
  5241.  
  5242.     return(ER_NOERROR);
  5243. }
  5244.  
  5245. /****** td.library/tdQuadAdd4dv ******************************************
  5246. * 
  5247. *   NAME    
  5248. *     tdQuadAdd4dv -- Add a new polygon with 4 vertices to the
  5249. *                    current object, this according the CTM.
  5250. *                    The polygon will have the current
  5251. *                    material.
  5252. *
  5253. *   SYNOPSIS
  5254. *    error = tdQuadAdd4dv
  5255. *              ( spacehandle,vertex1,vertex2,vertex3,vertex4 )
  5256. *                D1           A0       A1      A2     A3
  5257. *
  5258. *    TDerrors tdQuadAdd4dv
  5259. *         ( ULONG,TDvectord *,TDvectord *,TDvectord *,TDvectord * );
  5260. *
  5261. *   FUNCTION
  5262. *    A new polygon with 4 vertices will be automatically created.
  5263. *    The vertices added to the current object its list and
  5264. *    assigned to the new polygon which will have the 
  5265. *    current material.
  5266. *
  5267. *    A copy of the contents passed by the vector pointers will be made.
  5268. *    The current polygon of the object will be reset, and not set to this one !
  5269. * 
  5270. *   INPUTS
  5271. *     spacehandle    - A valid handle of a space.
  5272. *    vertex1        - Pointer to the first veretex.
  5273. *    vertex2        - Pointer to the second vertex.
  5274. *    vertex3        - Pointer to the third vertex.
  5275. *    vertex4        - Pointer to the fourth vertex.
  5276. *    
  5277. *   RESULT
  5278. *     error - ER_NOERROR    if all went well.
  5279. *            ER_NOSPACE    if the handle is not valid.
  5280. *            ER_NOOBJECT   if there is no current object.
  5281. *            ER_NOMATGROUP if there is no current material group.
  5282. *            ER_NOMEMORY   if there is not enough memory. 
  5283. * 
  5284. *   EXAMPLE
  5285. *    error = tdQuadAdd4dv(spacehandle,&v1,&v2,&v3,&v4);
  5286. *
  5287. *   NOTES
  5288. *    Vertices have to be added in counterclock wise direction.
  5289. *
  5290. *    v4----v3
  5291. *    |      |
  5292. *    |      |
  5293. *    |      |
  5294. *    |      |
  5295. *    |      |
  5296. *    v1--->v2
  5297. *
  5298. *   BUGS
  5299. * 
  5300. *   SEE ALSO
  5301. *     tdTriangleAdd()
  5302. * 
  5303. ******************************************************************************
  5304. *
  5305. */
  5306. TDerrors __saveds ASM tdQuadAdd4dv(register __d1 ULONG spacehandle,
  5307.                                     register __a0 TDvectord *vertex1,
  5308.                                     register __a1 TDvectord *vertex2,
  5309.                                     register __a2 TDvectord *vertex3,
  5310.                                     register __a3 TDvectord *vertex4) {
  5311.  
  5312.     TDspace        *space=NULL;
  5313.     TDpolymesh        *polymesh=NULL;
  5314.     TDmatgroupnode    *matgroupnode=NULL;
  5315.     TDpolygonnode    *polynode=NULL;
  5316.     TDvectord        *mvertex1=NULL,*mvertex2=NULL,
  5317.                     *mvertex3=NULL,*mvertex4=NULL;
  5318.     ULONG            vindex;
  5319.  
  5320.     // make a copy of vertex1 to 4, a0 and a1 are a scratch registers
  5321.     mvertex1=vertex1;
  5322.     mvertex2=vertex2;
  5323.     mvertex3=vertex3;
  5324.     mvertex4=vertex4;
  5325.  
  5326.     space=(TDspace *) spacehandle;
  5327.     if (space==NULL) return(ER_NOSPACE);
  5328.  
  5329.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5330.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5331.  
  5332.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  5333.         
  5334.     // get the matgroup
  5335.     matgroupnode=polymesh->curmatgroupn;
  5336.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  5337.  
  5338.     // Create a new polygon, add it to the internal list
  5339.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  5340.  
  5341.     polymesh->curpolyn=NULL;
  5342.  
  5343.     if((vindex=addVertex(polymesh,space->ctm,(*mvertex1)))==0) return(ER_NOMEMORY);
  5344.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5345.     if((vindex=addVertex(polymesh,space->ctm,(*mvertex2)))==0) return(ER_NOMEMORY);
  5346.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5347.     if((vindex=addVertex(polymesh,space->ctm,(*mvertex3)))==0) return(ER_NOMEMORY);
  5348.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5349.     if((vindex=addVertex(polymesh,space->ctm,(*mvertex4)))==0) return(ER_NOMEMORY);
  5350.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5351.  
  5352.     return(ER_NOERROR);
  5353. }
  5354.  
  5355. /****** td.library/tdQuadAdd4fv ******************************************
  5356. * 
  5357. *   NAME    
  5358. *     tdQuadAdd4fv -- Add a new polygon with 4 vertices to the
  5359. *                    current object, this according the CTM.
  5360. *                    The polygon will have the current
  5361. *                    material.
  5362. *
  5363. *   SYNOPSIS
  5364. *    error = tdQuadAdd4fv
  5365. *              ( spacehandle,vertex1,vertex2,vertex3,vertex4 )
  5366. *                D1           A0       A1      A2     A3
  5367. *
  5368. *    TDerrors tdQuadAdd4fv
  5369. *         ( ULONG,TDvectorf *,TDvectorf *,TDvectorf *,TDvectorf * );
  5370. *
  5371. *   FUNCTION
  5372. *    A new polygon with 4 vertices will be automatically created.
  5373. *    The vertices added to the current object its list and
  5374. *    assigned to the new polygon which will have the 
  5375. *    current material.
  5376. *
  5377. *    A copy of the contents passed by the vector pointers will be made.
  5378. *    The current polygon of the object will be reset, and not set to this one !
  5379. * 
  5380. *   INPUTS
  5381. *     spacehandle    - A valid handle of a space.
  5382. *    vertex1        - Pointer to the first veretex.
  5383. *    vertex2        - Pointer to the second vertex.
  5384. *    vertex3        - Pointer to the third vertex.
  5385. *    vertex4        - Pointer to the fourth vertex.
  5386. *    
  5387. *   RESULT
  5388. *     error - ER_NOERROR    if all went well.
  5389. *            ER_NOSPACE    if the handle is not valid.
  5390. *            ER_NOOBJECT   if there is no current object.
  5391. *            ER_NOMATGROUP if there is no current material group.
  5392. *            ER_NOMEMORY   if there is not enough memory. 
  5393. * 
  5394. *   EXAMPLE
  5395. *    error = tdQuadAdd4fv(spacehandle,&v1,&v2,&v3,&v4);
  5396. *
  5397. *   NOTES
  5398. *    Vertices have to be added in counterclock wise direction.
  5399. *
  5400. *    v4----v3
  5401. *    |      |
  5402. *    |      |
  5403. *    |      |
  5404. *    |      |
  5405. *    |      |
  5406. *    v1--->v2
  5407. *
  5408. *   BUGS
  5409. * 
  5410. *   SEE ALSO
  5411. *     tdTriangleAdd()
  5412. * 
  5413. ******************************************************************************
  5414. *
  5415. */
  5416. TDerrors __saveds ASM tdQuadAdd4fv(register __d1 ULONG spacehandle,
  5417.                                     register __a0 TDvectorf *vertex1,
  5418.                                     register __a1 TDvectorf *vertex2,
  5419.                                     register __a2 TDvectorf *vertex3,
  5420.                                     register __a3 TDvectorf *vertex4) {
  5421.  
  5422.     TDspace        *space=NULL;
  5423.     TDpolymesh        *polymesh=NULL;
  5424.     TDmatgroupnode    *matgroupnode=NULL;
  5425.     TDpolygonnode    *polynode=NULL;
  5426.     TDvectord        mvertex1,mvertex2,
  5427.                     mvertex3,mvertex4;
  5428.     ULONG            vindex;
  5429.  
  5430.     // make a copy of vertex1 to 4, a0 and a1 are a scratch registers
  5431.     mvertex1.x=vertex1->x;
  5432.     mvertex1.y=vertex1->y;
  5433.     mvertex1.z=vertex1->z;
  5434.  
  5435.     mvertex2.x=vertex2->x;
  5436.     mvertex2.y=vertex2->y;
  5437.     mvertex2.z=vertex2->z;
  5438.  
  5439.     mvertex3.x=vertex3->x;
  5440.     mvertex3.y=vertex3->y;
  5441.     mvertex3.z=vertex3->z;
  5442.  
  5443.     mvertex4.x=vertex4->x;
  5444.     mvertex4.y=vertex4->y;
  5445.     mvertex4.z=vertex4->z;
  5446.  
  5447.     space=(TDspace *) spacehandle;
  5448.     if (space==NULL) return(ER_NOSPACE);
  5449.  
  5450.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5451.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5452.  
  5453.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  5454.         
  5455.     // get the matgroup, must be present if material is set !
  5456.     matgroupnode=polymesh->curmatgroupn;
  5457.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  5458.  
  5459.     // Create a new polygon, add it to the internal list
  5460.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  5461.  
  5462.     polymesh->curpolyn=NULL;
  5463.  
  5464.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  5465.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5466.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  5467.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5468.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  5469.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5470.     if((vindex=addVertex(polymesh,space->ctm,mvertex4))==0) return(ER_NOMEMORY);
  5471.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5472.  
  5473.     return(ER_NOERROR);
  5474. }
  5475.  
  5476. /****** td.library/tdQuadAdd12da ******************************************
  5477. * 
  5478. *   NAME    
  5479. *     tdQuadAdd12da -- Add a new polygon with 4 vertices to the
  5480. *                     current object, this according the CTM.
  5481. *                     The polygon will have the current
  5482. *                     material.
  5483. *
  5484. *   SYNOPSIS
  5485. *    error = tdQuadAdd12da
  5486. *              ( spacehandle,array )
  5487. *                D1           A0
  5488. *
  5489. *    TDerrors tdQuadAdd12da
  5490. *         ( ULONG,TDdouble [12] );
  5491. *
  5492. *   FUNCTION
  5493. *    A new polygon with 4 vertices will be automatically created.
  5494. *    The vertices added to the current object its list and
  5495. *    assigned to the new polygon which will have the 
  5496. *    current material.
  5497. *
  5498. *    A copy of the contents passed by the vector pointers will be made.
  5499. *    The current polygon of the object will be reset, and not set to this one !
  5500. * 
  5501. *   INPUTS
  5502. *     spacehandle    - A valid handle of a space.
  5503. *    array          - Array which contains all 12 coordinates.
  5504. *    
  5505. *   RESULT
  5506. *     error - ER_NOERROR    if all went well.
  5507. *            ER_NOSPACE    if the handle is not valid.
  5508. *            ER_NOOBJECT   if there is no current object.
  5509. *            ER_NOMATGROUP if there is no current material group.
  5510. *            ER_NOMEMORY   if there is not enough memory. 
  5511. * 
  5512. *   EXAMPLE
  5513. *    error = tdQuadAdd12da(spacehandle,array);
  5514. *
  5515. *   NOTES
  5516. *    Vertices have to be added in counterclock wise direction.
  5517. *
  5518. *    v4----v3
  5519. *    |      |
  5520. *    |      |
  5521. *    |      |
  5522. *    |      |
  5523. *    |      |
  5524. *    v1--->v2
  5525. *
  5526. *   BUGS
  5527. * 
  5528. *   SEE ALSO
  5529. *     tdTriangleAdd()
  5530. * 
  5531. ******************************************************************************
  5532. *
  5533. */
  5534. TDerrors __saveds ASM tdQuadAdd12da(register __d1 ULONG spacehandle,
  5535.                                     register __a0 TDdouble array[12]) {
  5536.  
  5537.     TDspace        *space=NULL;
  5538.     TDpolymesh        *polymesh=NULL;
  5539.     TDmatgroupnode    *matgroupnode=NULL;
  5540.     TDpolygonnode    *polynode=NULL;
  5541.     TDvectord        mvertex1,mvertex2,
  5542.                     mvertex3,mvertex4;
  5543.     ULONG            vindex;
  5544.  
  5545.     // make a copy of vertex1 to 4, a0 and a1 are a scratch registers
  5546.     mvertex1.x=array[0];
  5547.     mvertex1.y=array[1];
  5548.     mvertex1.z=array[2];
  5549.  
  5550.     mvertex2.x=array[3];
  5551.     mvertex2.y=array[4];
  5552.     mvertex2.z=array[5];
  5553.  
  5554.     mvertex3.x=array[6];
  5555.     mvertex3.y=array[7];
  5556.     mvertex3.z=array[8];
  5557.  
  5558.     mvertex4.x=array[9];
  5559.     mvertex4.y=array[10];
  5560.     mvertex4.z=array[11];
  5561.  
  5562.     space=(TDspace *) spacehandle;
  5563.     if (space==NULL) return(ER_NOSPACE);
  5564.  
  5565.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5566.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5567.  
  5568.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  5569.         
  5570.     // get the matgroup, must be present if material is set !
  5571.     matgroupnode=polymesh->curmatgroupn;
  5572.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  5573.  
  5574.     // Create a new polygon, add it to the internal list
  5575.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  5576.  
  5577.     polymesh->curpolyn=NULL;
  5578.  
  5579.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  5580.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5581.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  5582.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5583.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  5584.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5585.     if((vindex=addVertex(polymesh,space->ctm,mvertex4))==0) return(ER_NOMEMORY);
  5586.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5587.  
  5588.     return(ER_NOERROR);
  5589. }
  5590.  
  5591. /****** td.library/tdQuadAdd12fa ******************************************
  5592. * 
  5593. *   NAME    
  5594. *     tdQuadAdd12fa -- Add a new polygon with 4 vertices to the
  5595. *                     current object, this according the CTM.
  5596. *                     The polygon will have the current
  5597. *                     material.
  5598. *
  5599. *   SYNOPSIS
  5600. *    error = tdQuadAdd12fa
  5601. *              ( spacehandle,array )
  5602. *                D1           A0
  5603. *
  5604. *    TDerrors tdQuadAdd12fa
  5605. *         ( ULONG,TDfloat [12] );
  5606. *
  5607. *   FUNCTION
  5608. *    A new polygon with 4 vertices will be automatically created.
  5609. *    The vertices added to the current object its list and
  5610. *    assigned to the new polygon which will have the 
  5611. *    current material.
  5612. *
  5613. *    A copy of the contents passed by the vector pointers will be made.
  5614. *    The current polygon of the object will be reset, and not set to this one !
  5615. * 
  5616. *   INPUTS
  5617. *     spacehandle    - A valid handle of a space.
  5618. *    array          - Array which contains all 12 coordinates.
  5619. *    
  5620. *   RESULT
  5621. *     error - ER_NOERROR    if all went well.
  5622. *            ER_NOSPACE    if the handle is not valid.
  5623. *            ER_NOOBJECT   if there is no current object.
  5624. *            ER_NOMATGROUP if there is no current material group.
  5625. *            ER_NOMEMORY   if there is not enough memory. 
  5626. * 
  5627. *   EXAMPLE
  5628. *    error = tdQuadAdd12fa(spacehandle,array);
  5629. *
  5630. *   NOTES
  5631. *    Vertices have to be added in counterclock wise direction.
  5632. *
  5633. *    v4----v3
  5634. *    |      |
  5635. *    |      |
  5636. *    |      |
  5637. *    |      |
  5638. *    |      |
  5639. *    v1--->v2
  5640. *
  5641. *   BUGS
  5642. * 
  5643. *   SEE ALSO
  5644. *     tdTriangleAdd()
  5645. * 
  5646. ******************************************************************************
  5647. *
  5648. */
  5649. TDerrors __saveds ASM tdQuadAdd12fa(register __d1 ULONG spacehandle,
  5650.                                     register __a0 TDfloat array[12]) {
  5651.  
  5652.     TDspace        *space=NULL;
  5653.     TDpolymesh        *polymesh=NULL;
  5654.     TDmatgroupnode    *matgroupnode=NULL;
  5655.     TDpolygonnode    *polynode=NULL;
  5656.     TDvectord        mvertex1,mvertex2,
  5657.                     mvertex3,mvertex4;
  5658.     ULONG            vindex;
  5659.  
  5660.     // make a copy of vertex1 to 4, a0 and a1 are a scratch registers
  5661.     mvertex1.x=array[0];
  5662.     mvertex1.y=array[1];
  5663.     mvertex1.z=array[2];
  5664.  
  5665.     mvertex2.x=array[3];
  5666.     mvertex2.y=array[4];
  5667.     mvertex2.z=array[5];
  5668.  
  5669.     mvertex3.x=array[6];
  5670.     mvertex3.y=array[7];
  5671.     mvertex3.z=array[8];
  5672.  
  5673.     mvertex4.x=array[9];
  5674.     mvertex4.y=array[10];
  5675.     mvertex4.z=array[11];
  5676.  
  5677.     space=(TDspace *) spacehandle;
  5678.     if (space==NULL) return(ER_NOSPACE);
  5679.  
  5680.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5681.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5682.  
  5683.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  5684.         
  5685.     // get the matgroup, must be present if material is set !
  5686.     matgroupnode=polymesh->curmatgroupn;
  5687.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  5688.  
  5689.     // Create a new polygon, add it to the internal list
  5690.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  5691.  
  5692.     polymesh->curpolyn=NULL;
  5693.  
  5694.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  5695.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5696.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  5697.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5698.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  5699.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5700.     if((vindex=addVertex(polymesh,space->ctm,mvertex4))==0) return(ER_NOMEMORY);
  5701.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5702.  
  5703.     return(ER_NOERROR);
  5704. }
  5705.  
  5706. /****** td.library/tdTriangleAdd3dv ******************************************
  5707. * 
  5708. *   NAME    
  5709. *     tdTriangleAdd3dv -- Add a new polygon with 3 vertices to the
  5710. *                        current object, this according the CTM.
  5711. *                        The polygon will have the current
  5712. *                        material.
  5713. *
  5714. *   SYNOPSIS
  5715. *    error = tdTriangleAdd3dv
  5716. *              ( spacehandle,vertex1,vertex2,vertex3 )
  5717. *                D1           A0       A1      A2
  5718. *
  5719. *    TDerrors tdTriangleAdd3dv
  5720. *         ( ULONG,TDvectord *,TDvectord *,TDvectord * );
  5721. *
  5722. *   FUNCTION
  5723. *    A new polygon with 3 vertices will be automatically created.
  5724. *    The vertices added to the current object its list and
  5725. *    assigned to the new polygon which will have the 
  5726. *    current material.
  5727. *
  5728. *    A copy of the contents passed by the vector pointers will be made.
  5729. *    The current polygon of the object will be reset, and not set to this one !
  5730. * 
  5731. *   INPUTS
  5732. *     spacehandle    - A valid handle of a space.
  5733. *    vertex1        - Pointer to the first veretex.
  5734. *    vertex2        - Pointer to the second vertex.
  5735. *    vertex3        - Pointer to the third vertex.
  5736. *    
  5737. *   RESULT
  5738. *     error - ER_NOERROR    if all went well.
  5739. *            ER_NOSPACE    if the handle is not valid.
  5740. *            ER_NOOBJECT   if there is no current object.
  5741. *            ER_NOMATGROUP if there is no current material group.
  5742. *            ER_NOMEMORY   if there is not enough memory. 
  5743. * 
  5744. *   EXAMPLE
  5745. *    error = tdTriangleAdd3dv(spacehandle,&v1,&v2,&v3);
  5746. *
  5747. *   NOTES
  5748. *    Vertices have to be added in counterclock wise direction.
  5749. *
  5750. *          v3
  5751. *         / |
  5752. *        /  |
  5753. *       /   |
  5754. *      /    |
  5755. *     /     |
  5756. *    v1--->v2
  5757. *
  5758. *   BUGS
  5759. * 
  5760. *   SEE ALSO
  5761. *     tdQuadAdd()
  5762. * 
  5763. ******************************************************************************
  5764. *
  5765. */
  5766. TDerrors __saveds ASM tdTriangleAdd3dv(register __d1 ULONG spacehandle,
  5767.                                         register __a0 TDvectord *vertex1,
  5768.                                         register __a1 TDvectord *vertex2,
  5769.                                         register __a2 TDvectord *vertex3) {
  5770.  
  5771.     TDspace        *space=NULL;
  5772.     TDpolymesh        *polymesh=NULL;
  5773.     TDmatgroupnode    *matgroupnode=NULL;
  5774.     TDpolygonnode    *polynode=NULL;
  5775.     TDvectord        mvertex1,mvertex2,
  5776.                     mvertex3;
  5777.     ULONG            vindex;
  5778.  
  5779.     // make a copy of vertex1 to 3, a0 and a1 are a scratch registers
  5780.     mvertex1=(*vertex1);
  5781.     mvertex2=(*vertex2);
  5782.     mvertex3=(*vertex3);
  5783.  
  5784.     space=(TDspace *) spacehandle;
  5785.     if (space==NULL) return(ER_NOSPACE);
  5786.  
  5787.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5788.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5789.  
  5790.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  5791.         
  5792.     // get the matgroup, must be present if material is set !
  5793.     matgroupnode=polymesh->curmatgroupn;
  5794.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  5795.  
  5796.     // Create a new polygon, add it to the internal list
  5797.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  5798.  
  5799.     polymesh->curpolyn=NULL;
  5800.  
  5801.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  5802.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5803.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  5804.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5805.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  5806.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5807.  
  5808.     return(ER_NOERROR);
  5809. }
  5810.  
  5811. /****** td.library/tdTriangleAdd3fv ******************************************
  5812. * 
  5813. *   NAME    
  5814. *     tdTriangleAdd3fv -- Add a new polygon with 3 vertices to the
  5815. *                        current object, this according the CTM.
  5816. *                        The polygon will have the current
  5817. *                        material.
  5818. *
  5819. *   SYNOPSIS
  5820. *    error = tdTriangleAdd3fv
  5821. *              ( spacehandle,vertex1,vertex2,vertex3 )
  5822. *                D1           A0       A1      A2
  5823. *
  5824. *    TDerrors tdTriangleAdd3fv
  5825. *         ( ULONG,TDvectorf *,TDvectorf *,TDvectorf * );
  5826. *
  5827. *   FUNCTION
  5828. *    A new polygon with 3 vertices will be automatically created.
  5829. *    The vertices added to the current object its list and
  5830. *    assigned to the new polygon which will have the 
  5831. *    current material.
  5832. *
  5833. *    A copy of the contents passed by the vector pointers will be made.
  5834. *    The current polygon of the object will be reset, and not set to this one !
  5835. * 
  5836. *   INPUTS
  5837. *     spacehandle    - A valid handle of a space.
  5838. *    vertex1        - Pointer to the first veretex.
  5839. *    vertex2        - Pointer to the second vertex.
  5840. *    vertex3        - Pointer to the third vertex.
  5841. *    
  5842. *   RESULT
  5843. *     error - ER_NOERROR    if all went well.
  5844. *            ER_NOSPACE    if the handle is not valid.
  5845. *            ER_NOOBJECT   if there is no current object.
  5846. *            ER_NOMATGROUP if there is no current material group.
  5847. *            ER_NOMEMORY   if there is not enough memory. 
  5848. * 
  5849. *   EXAMPLE
  5850. *    error = tdTriangleAdd3fv(spacehandle,&v1,&v2,&v3);
  5851. *
  5852. *   NOTES
  5853. *    Vertices have to be added in counterclock wise direction.
  5854. *
  5855. *          v3
  5856. *         / |
  5857. *        /  |
  5858. *       /   |
  5859. *      /    |
  5860. *     /     |
  5861. *    v1--->v2
  5862. *
  5863. *   BUGS
  5864. * 
  5865. *   SEE ALSO
  5866. *     tdQuadAdd()
  5867. * 
  5868. ******************************************************************************
  5869. *
  5870. */
  5871. TDerrors __saveds ASM tdTriangleAdd3fv(register __d1 ULONG spacehandle,
  5872.                                         register __a0 TDvectorf *vertex1,
  5873.                                         register __a1 TDvectorf *vertex2,
  5874.                                         register __a2 TDvectorf *vertex3) {
  5875.  
  5876.     TDspace        *space=NULL;
  5877.     TDpolymesh        *polymesh=NULL;
  5878.     TDmatgroupnode    *matgroupnode=NULL;
  5879.     TDpolygonnode    *polynode=NULL;
  5880.     TDvectord        mvertex1,mvertex2,
  5881.                     mvertex3;
  5882.     ULONG            vindex;
  5883.  
  5884.     // make a copy of vertex1 to 3, a0 and a1 are a scratch registers
  5885.     mvertex1.x=vertex1->x;
  5886.     mvertex1.y=vertex1->y;
  5887.     mvertex1.z=vertex1->z;
  5888.  
  5889.     mvertex2.x=vertex2->x;
  5890.     mvertex2.y=vertex2->y;
  5891.     mvertex2.z=vertex2->z;
  5892.  
  5893.     mvertex3.x=vertex3->x;
  5894.     mvertex3.y=vertex3->y;
  5895.     mvertex3.z=vertex3->z;
  5896.  
  5897.     space=(TDspace *) spacehandle;
  5898.     if (space==NULL) return(ER_NOSPACE);
  5899.  
  5900.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  5901.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  5902.  
  5903.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  5904.         
  5905.     // get the matgroup, must be present if material is set !
  5906.     matgroupnode=polymesh->curmatgroupn;
  5907.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  5908.  
  5909.     // Create a new polygon, add it to the internal list
  5910.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  5911.  
  5912.     polymesh->curpolyn=NULL;
  5913.  
  5914.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  5915.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5916.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  5917.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5918.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  5919.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  5920.  
  5921.     return(ER_NOERROR);
  5922. }
  5923.  
  5924. /****** td.library/tdTriangleAdd9da ******************************************
  5925. * 
  5926. *   NAME    
  5927. *     tdTriangleAdd9da -- Add a new polygon with 3 vertices to the
  5928. *                        current object, this according the CTM.
  5929. *                        The polygon will have the current
  5930. *                        material.
  5931. *
  5932. *   SYNOPSIS
  5933. *    error = tdTriangleAdd9da
  5934. *              ( spacehandle,array )
  5935. *                D1           A0
  5936. *
  5937. *    TDerrors tdTriangleAdd9da
  5938. *         ( ULONG,TDdouble [9] );
  5939. *
  5940. *   FUNCTION
  5941. *    A new polygon with 3 vertices will be automatically created.
  5942. *    The vertices added to the current object its list and
  5943. *    assigned to the new polygon which will have the 
  5944. *    current material.
  5945. *
  5946. *    A copy of the contents passed by the vector pointers will be made.
  5947. *    The current polygon of the object will be reset, and not set to this one !
  5948. * 
  5949. *   INPUTS
  5950. *     spacehandle    - A valid handle of a space.
  5951. *    array          - Array which contains the coordinates.
  5952. *    
  5953. *   RESULT
  5954. *     error - ER_NOERROR    if all went well.
  5955. *            ER_NOSPACE    if the handle is not valid.
  5956. *            ER_NOOBJECT   if there is no current object.
  5957. *            ER_NOMATGROUP if there is no current material group.
  5958. *            ER_NOMEMORY   if there is not enough memory. 
  5959. * 
  5960. *   EXAMPLE
  5961. *    error = tdTriangleAdd9da(spacehandle,array);
  5962. *
  5963. *   NOTES
  5964. *    Vertices have to be added in counterclock wise direction.
  5965. *
  5966. *          v3
  5967. *         / |
  5968. *        /  |
  5969. *       /   |
  5970. *      /    |
  5971. *     /     |
  5972. *    v1--->v2
  5973. *
  5974. *   BUGS
  5975. * 
  5976. *   SEE ALSO
  5977. *     tdQuadAdd()
  5978. * 
  5979. ******************************************************************************
  5980. *
  5981. */
  5982. TDerrors __saveds ASM tdTriangleAdd9da(register __d1 ULONG spacehandle,
  5983.                                         register __a0 TDdouble array[9]) {
  5984.  
  5985.     TDspace        *space=NULL;
  5986.     TDpolymesh        *polymesh=NULL;
  5987.     TDmatgroupnode    *matgroupnode=NULL;
  5988.     TDpolygonnode    *polynode=NULL;
  5989.     TDvectord        mvertex1,mvertex2,
  5990.                     mvertex3;
  5991.     ULONG            vindex;
  5992.  
  5993.     // make a copy of vertex1 to 3, a0 and a1 are a scratch registers
  5994.     mvertex1.x=array[0];
  5995.     mvertex1.y=array[1];
  5996.     mvertex1.z=array[2];
  5997.  
  5998.     mvertex2.x=array[3];
  5999.     mvertex2.y=array[4];
  6000.     mvertex2.z=array[5];
  6001.  
  6002.     mvertex3.x=array[6];
  6003.     mvertex3.y=array[7];
  6004.     mvertex3.z=array[8];
  6005.  
  6006.     space=(TDspace *) spacehandle;
  6007.     if (space==NULL) return(ER_NOSPACE);
  6008.  
  6009.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  6010.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  6011.  
  6012.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  6013.         
  6014.     // get the matgroup, must be present if material is set !
  6015.     matgroupnode=polymesh->curmatgroupn;
  6016.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  6017.  
  6018.     // Create a new polygon, add it to the internal list
  6019.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  6020.  
  6021.     polymesh->curpolyn=NULL;
  6022.  
  6023.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  6024.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  6025.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  6026.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  6027.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  6028.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  6029.  
  6030.     return(ER_NOERROR);
  6031. }
  6032.  
  6033. /****** td.library/tdTriangleAdd9fa ******************************************
  6034. * 
  6035. *   NAME    
  6036. *     tdTriangleAdd9fa -- Add a new polygon with 3 vertices to the
  6037. *                        current object, this according the CTM.
  6038. *                        The polygon will have the current
  6039. *                        material.
  6040. *
  6041. *   SYNOPSIS
  6042. *    error = tdTriangleAdd9fa
  6043. *              ( spacehandle,array )
  6044. *                D1           A0
  6045. *
  6046. *    TDerrors tdTriangleAdd9fa
  6047. *         ( ULONG,TDfloat [9] );
  6048. *
  6049. *   FUNCTION
  6050. *    A new polygon with 3 vertices will be automatically created.
  6051. *    The vertices added to the current object its list and
  6052. *    assigned to the new polygon which will have the 
  6053. *    current material.
  6054. *
  6055. *    A copy of the contents passed by the vector pointers will be made.
  6056. *    The current polygon of the object will be reset, and not set to this one !
  6057. * 
  6058. *   INPUTS
  6059. *     spacehandle    - A valid handle of a space.
  6060. *    array          - Array which contains the coordinates.
  6061. *    
  6062. *   RESULT
  6063. *     error - ER_NOERROR    if all went well.
  6064. *            ER_NOSPACE    if the handle is not valid.
  6065. *            ER_NOOBJECT   if there is no current object.
  6066. *            ER_NOMATGROUP if there is no current material group.
  6067. *            ER_NOMEMORY   if there is not enough memory. 
  6068. * 
  6069. *   EXAMPLE
  6070. *    error = tdTriangleAdd9fa(spacehandle,array);
  6071. *
  6072. *   NOTES
  6073. *    Vertices have to be added in counterclock wise direction.
  6074. *
  6075. *          v3
  6076. *         / |
  6077. *        /  |
  6078. *       /   |
  6079. *      /    |
  6080. *     /     |
  6081. *    v1--->v2
  6082. *
  6083. *   BUGS
  6084. * 
  6085. *   SEE ALSO
  6086. *     tdQuadAdd()
  6087. * 
  6088. ******************************************************************************
  6089. *
  6090. */
  6091. TDerrors __saveds ASM tdTriangleAdd9fa(register __d1 ULONG spacehandle,
  6092.                                         register __a0 TDfloat array[9]) {
  6093.  
  6094.     TDspace        *space=NULL;
  6095.     TDpolymesh        *polymesh=NULL;
  6096.     TDmatgroupnode    *matgroupnode=NULL;
  6097.     TDpolygonnode    *polynode=NULL;
  6098.     TDvectord        mvertex1,mvertex2,
  6099.                     mvertex3;
  6100.     ULONG            vindex;
  6101.  
  6102.     // make a copy of vertex1 to 3, a0 and a1 are a scratch registers
  6103.     mvertex1.x=array[0];
  6104.     mvertex1.y=array[1];
  6105.     mvertex1.z=array[2];
  6106.  
  6107.     mvertex2.x=array[3];
  6108.     mvertex2.y=array[4];
  6109.     mvertex2.z=array[5];
  6110.  
  6111.     mvertex3.x=array[6];
  6112.     mvertex3.y=array[7];
  6113.     mvertex3.z=array[8];
  6114.  
  6115.     space=(TDspace *) spacehandle;
  6116.     if (space==NULL) return(ER_NOSPACE);
  6117.  
  6118.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  6119.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  6120.  
  6121.     polymesh=(TDpolymesh *)(space->curobjn->handle);
  6122.         
  6123.     // get the matgroup, must be present if material is set !
  6124.     matgroupnode=polymesh->curmatgroupn;
  6125.     if(matgroupnode==NULL) return(ER_NOMATGROUP);
  6126.  
  6127.     // Create a new polygon, add it to the internal list
  6128.     if((polynode=addPolygon(polymesh,matgroupnode,Ci_POLYVERARRAYINIT))==NULL) return(ER_NOMEMORY);
  6129.  
  6130.     polymesh->curpolyn=NULL;
  6131.  
  6132.     if((vindex=addVertex(polymesh,space->ctm,mvertex1))==0) return(ER_NOMEMORY);
  6133.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  6134.     if((vindex=addVertex(polymesh,space->ctm,mvertex2))==0) return(ER_NOMEMORY);
  6135.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  6136.     if((vindex=addVertex(polymesh,space->ctm,mvertex3))==0) return(ER_NOMEMORY);
  6137.     if(assignVertex(polymesh,matgroupnode,polynode,vindex)==0) return(ER_NOMEMORY);
  6138.  
  6139.     return(ER_NOERROR);
  6140. }
  6141.  
  6142. /****** td.library/tdVertexAssign *************************************************
  6143. * 
  6144. *   NAME    
  6145. *     tdVertexAssign -- Assigns an existing vertex out of the object its
  6146. *                      vertex list to the current polygon.
  6147. *
  6148. *   SYNOPSIS
  6149. *    error = tdVertexAssign( spacehandle,index )
  6150. *                              D1        D2
  6151. *
  6152. *    TDerrors tdVertexAssign
  6153. *         ( ULONG,ULONG );
  6154. *
  6155. *   FUNCTION
  6156. *    An existing vertex, added with a tdVertexAdd or similar function
  6157. *    before to the object, can be assigned to the current polygon.
  6158. * 
  6159. *   INPUTS
  6160. *     spacehandle  - A valid handle of a space.
  6161. *    index        - The index of the vertex in the object its list.
  6162. *    
  6163. *   RESULT
  6164. *     error - ER_NOERROR    if all went well.
  6165. *            ER_NOSPACE    if the handle is not valid.
  6166. *            ER_NOOBJECT   if there is no current object.
  6167. *            ER_NOPOLYGON  if there is no current polygon.
  6168. *            ER_NOINDEX    if the index is not valid.
  6169. *            ER_NOMEMORY   if there is not enough memory. 
  6170. * 
  6171. *   EXAMPLE
  6172. *    error = tdVertexAssign(spacehandle,97);
  6173. *
  6174. *   NOTES
  6175. *    Vertices have to be assigned in counterclock wise direction.
  6176. *
  6177. *          v3
  6178. *         / |
  6179. *        /  |
  6180. *       /   |
  6181. *      /    |
  6182. *     /     |
  6183. *    v1--->v2
  6184. *
  6185. *   BUGS
  6186. * 
  6187. *   SEE ALSO
  6188. *     tdVertexAdd(),tdVertexGet(),
  6189. *    tdVertexIndexGet()
  6190. * 
  6191. ******************************************************************************
  6192. *
  6193. */
  6194. TDerrors __saveds ASM tdVertexAssign(register __d1 ULONG spacehandle,
  6195.                                     register __d2 ULONG index) {
  6196.  
  6197.     TDspace        *space=NULL;
  6198.     TDpolymesh        *mesh=NULL;
  6199.  
  6200.     space=(TDspace *) spacehandle;
  6201.     if (space==NULL) return(ER_NOSPACE);
  6202.  
  6203.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  6204.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  6205.  
  6206.     mesh=(TDpolymesh *)(space->curobjn->handle);
  6207.  
  6208.     if(mesh->vertices.numberOfVertices<1 || 
  6209.         index<1 || index>mesh->vertices.numberOfVertices) {
  6210.  
  6211.         return(ER_NOINDEX);
  6212.     }
  6213.  
  6214.     if(mesh->curpolyn!=NULL) {
  6215.         if(assignVertex(mesh,mesh->curmatgroupn,mesh->curpolyn,index)==0) return(ER_NOMEMORY);
  6216.     } else {
  6217.         return(ER_NOPOLYGON);
  6218.     }
  6219.  
  6220.     return(ER_NOERROR);
  6221. }
  6222.  
  6223. /****** td.library/tdVertexIndexGet *************************************************
  6224. * 
  6225. *   NAME    
  6226. *     tdVertexIndexGet -- Converts the index of a vertex in the current
  6227. *                        polygon to the index in the object its vertex list.
  6228. *
  6229. *   SYNOPSIS
  6230. *    error = tdVertexIndexGet( spacehandle,pindex,index )
  6231. *                              D1          D2     D3
  6232. *
  6233. *    TDerrors tdVertexIndexGet
  6234. *         ( ULONG,ULONG,ULONG * );
  6235. *
  6236. *   FUNCTION
  6237. *    Vertices in polygons are references to the vertices found
  6238. *    in the vertex list of the parent object. To get the index
  6239. *    of a vertex in the object with the help of the index in the
  6240. *    current polygon just call this function.
  6241. * 
  6242. *   INPUTS
  6243. *     spacehandle  - A valid handle of a space.
  6244. *    pindex       - The index of the vertex in the polygon.
  6245. *    index        - Pointer to the variable which will contain
  6246. *                   the index of the object list.
  6247. *    
  6248. *   RESULT
  6249. *     error - ER_NOERROR    if all went well.
  6250. *            ER_NOSPACE    if the handle is not valid.
  6251. *            ER_NOOBJECT   if there is no current object.
  6252. *            ER_NOPOLYGON  if there is no current polygon.
  6253. *            ER_NOINDEX    if the index is not valid.
  6254. * 
  6255. *   EXAMPLE
  6256. *    error = tdVertexIndexGet(spacehandle,97,&index);
  6257. *
  6258. *   NOTES
  6259. *
  6260. *   BUGS
  6261. * 
  6262. *   SEE ALSO
  6263. *     tdVertexAdd(),tdVertexGet(),
  6264. *    tdVertexAssign()
  6265. * 
  6266. ******************************************************************************
  6267. *
  6268. */
  6269. TDerrors __saveds ASM tdVertexIndexGet(register __d1 ULONG spacehandle,
  6270.                                     register __d2 ULONG pindex,
  6271.                                     register __d3 ULONG *index) {
  6272.  
  6273.     TDspace        *space=NULL;
  6274.     TDpolymesh        *mesh=NULL;
  6275.     TDpolygonnode    *polynode=NULL;
  6276.  
  6277.     space=(TDspace *) spacehandle;
  6278.     if (space==NULL) return(ER_NOSPACE);
  6279.  
  6280.     if(space->curobjn==NULL) return(ER_NOOBJECT);
  6281.     if(space->curobjn->type!=TD_POLYMESH) return(ER_NOOBJECT);
  6282.  
  6283.     mesh=(TDpolymesh *)(space->curobjn->handle);
  6284.  
  6285.     polynode=mesh->curpolyn;
  6286.     if(polynode==NULL) {
  6287.         return(ER_NOPOLYGON);
  6288.     }
  6289.  
  6290.     if(polynode->numberOfVertices<1 || 
  6291.         pindex<1 || pindex>polynode->numberOfVertices) {
  6292.  
  6293.         return(ER_NOINDEX);
  6294.     }
  6295.  
  6296.     (*index)=mesh->curpolyn->varray[pindex-1];
  6297.  
  6298.     return(ER_NOERROR);
  6299. }
  6300.  
  6301. /****** td.library/tdChildSetl ******************************************
  6302. * 
  6303. *   NAME    
  6304. *     tdChildSetl -- Set a parameter of the current child.
  6305. * 
  6306. *   SYNOPSIS
  6307. *    error = tdChildSetl( spacehandle,type,value )
  6308. *                         D1          D2   D3
  6309. *
  6310. *    TDerrors tdChildSetl
  6311. *         ( ULONG,TDenum,ULONG );
  6312. *
  6313. *   FUNCTION
  6314. *    The parameter of the current child, will be changed.
  6315. *    Type specifies which parameter.
  6316. * 
  6317. *   INPUTS
  6318. *     spacehandle     - A valid handle of a space.
  6319. *    type            - The parameter its type.
  6320. *    value           - The new value of the parameter.
  6321. *    
  6322. *   RESULT
  6323. *     error - ER_NOERROR    if all went well.
  6324. *            ER_NOSPACE    if the handle is not valid.
  6325. *            ER_NOOBJECT   if there is no current object.
  6326. *            ER_NOMATGROUP if there is no current material group.
  6327. *            ER_NOVALUE    if the value is incorrect.
  6328. *            ER_NOTYPE     if the type is not valid.
  6329. *
  6330. *   EXAMPLE
  6331. *    error = tdChildSetl(spacehandle,TD_TEXBINDING,36);
  6332. *
  6333. *   NOTES
  6334. *
  6335. *   BUGS
  6336. * 
  6337. *   SEE ALSO
  6338. *     tdChildGet(),tdCurrentSet()
  6339. * 
  6340. ******************************************************************************
  6341. *
  6342. */
  6343. TDerrors __saveds ASM tdChildSetl(register __d1 ULONG spacehandle,
  6344.                                     register __d2 TDenum type,
  6345.                                     register __d3 ULONG value) {
  6346.     TDspace        *space=NULL;
  6347.     TDobjectnode    *object=NULL;
  6348.     TDobjectnode    *object2=NULL;
  6349.     TDpolymesh        *polymesh=NULL;
  6350.     TDmatgroupnode    *matgroupn=NULL;
  6351.     TDmaterialnode    *matnode=NULL;
  6352.  
  6353.     space=(TDspace *) spacehandle;
  6354.     if (space==NULL) return(ER_NOSPACE);
  6355.  
  6356.     // set the value of the current child in function of the type
  6357.     switch(type) {
  6358.         case TD_MATERIAL :
  6359.             object=space->curobjn;
  6360.             if(object==NULL) return(ER_NOOBJECT);
  6361.  
  6362.             switch(object->type) {
  6363.                 case TD_POLYMESH :
  6364.                     polymesh=(TDpolymesh *)object->handle;
  6365.  
  6366.                     matgroupn=polymesh->curmatgroupn;
  6367.                     if(matgroupn==NULL) return(ER_NOMATGROUP);
  6368.  
  6369.                     if((matnode=getMaterialNode(space,value))==NULL) return(ER_NOVALUE);
  6370.                     if(matnode->type==TD_TEXTURE) return(ER_NOVALUE);
  6371.  
  6372.                     matgroupn->materialnode=matnode;
  6373.  
  6374.                     break;
  6375.             }
  6376.  
  6377.             break;
  6378.         case TD_TEXBINDING :
  6379.             object=space->curobjn;
  6380.             if(object==NULL) return(ER_NOOBJECT);
  6381.  
  6382.             switch(object->type) {
  6383.                 case TD_POLYMESH :
  6384.                     polymesh=(TDpolymesh *)object->handle;
  6385.  
  6386.                     matgroupn=polymesh->curmatgroupn;
  6387.                     if(matgroupn==NULL) return(ER_NOMATGROUP);
  6388.  
  6389.                     if((object2=getObjectNode(space,value))==NULL) return(ER_NOVALUE);
  6390.                     if(object2->type!=TD_TEXBINDING) return(ER_NOVALUE);
  6391.  
  6392.                     matgroupn->texbindex=value;
  6393.  
  6394.                     break;
  6395.             }
  6396.  
  6397.             break;
  6398.         default :
  6399.             return(ER_NOTYPE);
  6400.     }
  6401.  
  6402.     return(ER_NOERROR);
  6403. }
  6404.  
  6405. /****** td.library/tdChildGetl ******************************************
  6406. * 
  6407. *   NAME    
  6408. *     tdChildGetl -- Get a parameter of the current child.
  6409. * 
  6410. *   SYNOPSIS
  6411. *    error = tdChildGetl( spacehandle,type,value )
  6412. *                         D1          D2   D3
  6413. *
  6414. *    TDerrors tdChildGetl
  6415. *         ( ULONG,TDenum,ULONG * );
  6416. *
  6417. *   FUNCTION
  6418. *    The parameter of the current child, will be returned.
  6419. *    Type specifies which parameter.
  6420. * 
  6421. *   INPUTS
  6422. *     spacehandle     - A valid handle of a space.
  6423. *    type            - The parameter its type.
  6424. *    value           - The variable which will contain the parameter.
  6425. *    
  6426. *   RESULT
  6427. *     error - ER_NOERROR    if all went well.
  6428. *            ER_NOSPACE    if the handle is not valid.
  6429. *            ER_NOOBJECT   if there is no current object.
  6430. *            ER_NOMATGROUP if there is no current material group.
  6431. *            ER_NOVALUE    if the value is not set.
  6432. *            ER_NOTYPE     if the type is not valid.
  6433. *
  6434. *   EXAMPLE
  6435. *    error = tdChildGetl(spacehandle,TD_SURFACE,&value);
  6436. *
  6437. *   NOTES
  6438. *
  6439. *   BUGS
  6440. * 
  6441. *   SEE ALSO
  6442. *     tdChildSet(),tdCurrentSet()
  6443. * 
  6444. ******************************************************************************
  6445. *
  6446. */
  6447. TDerrors __saveds ASM tdChildGetl(register __d1 ULONG spacehandle,
  6448.                                     register __d2 TDenum type,
  6449.                                     register __d3 ULONG *value) {
  6450.     TDspace        *space=NULL;
  6451.     TDobjectnode    *object=NULL;
  6452.     TDpolymesh        *polymesh=NULL;
  6453.     TDmatgroupnode    *matgroupn=NULL;
  6454.  
  6455.     (*value)=0;
  6456.  
  6457.     space=(TDspace *) spacehandle;
  6458.     if (space==NULL) return(ER_NOSPACE);
  6459.  
  6460.     // get the value of the current child in function of the type
  6461.     switch(type) {
  6462.         case TD_MATERIAL :
  6463.             object=space->curobjn;
  6464.             if(object==NULL) return(ER_NOOBJECT);
  6465.  
  6466.             switch(object->type) {
  6467.                 case TD_POLYMESH :
  6468.                     polymesh=(TDpolymesh *)object->handle;
  6469.  
  6470.                     matgroupn=polymesh->curmatgroupn;
  6471.                     if(matgroupn==NULL) return(ER_NOMATGROUP);
  6472.  
  6473.                     (*value)=matgroupn->materialnode->index;
  6474.  
  6475.                     if((*value)==0) return(ER_NOVALUE);
  6476.  
  6477.                     break;
  6478.             }
  6479.  
  6480.             break;
  6481.         case TD_TEXBINDING :
  6482.             object=space->curobjn;
  6483.             if(object==NULL) return(ER_NOOBJECT);
  6484.  
  6485.             switch(object->type) {
  6486.                 case TD_POLYMESH :
  6487.                     polymesh=(TDpolymesh *)object->handle;
  6488.  
  6489.                     matgroupn=polymesh->curmatgroupn;
  6490.                     if(matgroupn==NULL) return(ER_NOMATGROUP);
  6491.  
  6492.                     (*value)=matgroupn->texbindex;
  6493.  
  6494.                     if((*value)==0) return(ER_NOVALUE);
  6495.  
  6496.                     break;
  6497.             }
  6498.         default :
  6499.             return(ER_NOTYPE);
  6500.     }
  6501.  
  6502.     return(ER_NOERROR);
  6503. }
  6504.  
  6505. /****** td.library/tdXNofGet ******************************************
  6506. * 
  6507. *   NAME    
  6508. *     tdXNofGet -- Returns the number of extensions of a
  6509. *                 spedific type.
  6510. * 
  6511. *   SYNOPSIS
  6512. *    number = tdXNofGet(type)
  6513. *                       D1
  6514. *
  6515. *    ULONG tdXNofGet
  6516. *         ( TDEnum );
  6517. *
  6518. *   FUNCTION
  6519. *    You will get the number of extensions in 
  6520. *    function of type.
  6521. * 
  6522. *   INPUTS
  6523. *    type - Type of extension.
  6524. *    
  6525. *   RESULT
  6526. *     number - Number of extensions.
  6527. *
  6528. *   EXAMPLE
  6529. *    number = tdXNofGet(TD_3X);
  6530. *
  6531. *   NOTES
  6532. *
  6533. *   BUGS
  6534. * 
  6535. *   SEE ALSO
  6536. *     tdXNameGet(),tdXExtGet(),tdXSupportedGet(),tdXDescGet(),
  6537. *    tdXLibGet()
  6538. * 
  6539. ******************************************************************************
  6540. *
  6541. */
  6542. ULONG __saveds ASM tdXNofGet(register __d1 TDenum type) {
  6543.     TDenum mtype;
  6544.     ULONG i,j;
  6545.  
  6546.     // make a copy of type, d1 is a scratch register
  6547.     mtype=type;
  6548.  
  6549.     switch(mtype) {
  6550.         case TD_3X :
  6551.             if(tdlibinfos->lib3dinfos!=NULL) {
  6552.                 i=0;
  6553.                 while(tdlibinfos->lib3dinfos[i]!=NULL) i++;
  6554.                 return(i);
  6555.             }
  6556.             break;
  6557.         case TD_3XSAVE :
  6558.             if(tdlibinfos->lib3dinfos!=NULL) {
  6559.                 j=0;
  6560.                 i=0;
  6561.                 while(tdlibinfos->lib3dinfos[i]!=NULL) {
  6562.                     if(tdlibinfos->lib3dinfos[i]->sups!=NULL) j++;
  6563.                     i++;
  6564.                 }
  6565.                 return(j);
  6566.             }
  6567.             break;
  6568.         case TD_3XLOAD :
  6569.             if(tdlibinfos->lib3dinfos!=NULL) {
  6570.                 j=0;
  6571.                 i=0;
  6572.                 while(tdlibinfos->lib3dinfos[i]!=NULL) {
  6573.                     if(tdlibinfos->lib3dinfos[i]->supl!=NULL) j++;
  6574.                     i++;
  6575.                 }
  6576.                 return(j);
  6577.             }
  6578.             break;
  6579.     }
  6580.  
  6581.     return(0);
  6582. }
  6583.  
  6584. /****** td.library/tdXExtGet ******************************************
  6585. * 
  6586. *   NAME    
  6587. *     tdXExtGet -- Returns the file extension of a specific
  6588. *                 extension.
  6589. * 
  6590. *   SYNOPSIS
  6591. *    extension = tdXExtGet(type,name)
  6592. *                          D1   D2
  6593. *
  6594. *    STRPTR tdXExtGet
  6595. *         ( TDEnum,STRPTR );
  6596. *
  6597. *   FUNCTION
  6598. *    You will get the file extension of the extension
  6599. *    with its name and type.
  6600. *
  6601. *    This strings are READ_ONLY and only valid as
  6602. *    long as the library is opened.
  6603. * 
  6604. *   INPUTS
  6605. *    type - Type of extension.
  6606. *    name - Name of the extension.
  6607. *    
  6608. *   RESULT
  6609. *     extension - Name of the extension, or NULL if none.
  6610. *
  6611. *   EXAMPLE
  6612. *    extension = tdXExtGet(TD_3X,"VRML");
  6613. *
  6614. *   NOTES
  6615. *
  6616. *   BUGS
  6617. * 
  6618. *   SEE ALSO
  6619. *     tdXNameGet(),tdXNofGet(),tdXSupportedGet(),tdXDescGet(),
  6620. *    tdXLibGet()
  6621. * 
  6622. ******************************************************************************
  6623. *
  6624. */
  6625. STRPTR __saveds ASM tdXExtGet(register __d1 TDenum type,register __d2 STRPTR name) {
  6626.     TDenum mtype;
  6627.     ULONG i;
  6628.  
  6629.     // make a copy of type, d1 is a scratch register
  6630.     mtype=type;
  6631.  
  6632.     switch(mtype) {
  6633.         case TD_3X :
  6634.         case TD_3XSAVE :
  6635.         case TD_3XLOAD :
  6636.             if(tdlibinfos->lib3dinfos!=NULL && name!=NULL) {
  6637.                 i=0;
  6638.                 while(tdlibinfos->lib3dinfos[i]!=NULL) {
  6639.                     if(strcmp(tdlibinfos->lib3dinfos[i]->name,name)==0) {
  6640.                         return(tdlibinfos->lib3dinfos[i]->ext);
  6641.                     }
  6642.                     i++;
  6643.                 }
  6644.             }
  6645.             break;
  6646.     }
  6647.  
  6648.     return(NULL);
  6649. }
  6650.  
  6651. /****** td.library/tdXNameGet ******************************************
  6652. * 
  6653. *   NAME    
  6654. *     tdXNameGet -- Returns the name of an extension.
  6655. * 
  6656. *   SYNOPSIS
  6657. *    name = tdXNameGet(type,index)
  6658. *                      D1   D2
  6659. *
  6660. *    STRPTR tdXNameGet
  6661. *         ( TDEnum,ULONG );
  6662. *
  6663. *   FUNCTION
  6664. *    You will get the name of an extension module by
  6665. *    specifying its type and the index of it.
  6666. *
  6667. *    This strings are READ_ONLY and only valid as
  6668. *    long as the library is opened.
  6669. * 
  6670. *   INPUTS
  6671. *    type     - Type of extension.
  6672. *    index    - Index of the extension.
  6673. *               0 -> tdXNofGet()-1
  6674. *    
  6675. *   RESULT
  6676. *     name - Name of NULL if none.
  6677. *
  6678. *   EXAMPLE
  6679. *    name = tdXNameGet(TD_3XSAVE,4);
  6680. *
  6681. *   NOTES
  6682. *    When you get NULL for a correct infex and type,
  6683. *    this means that the extension does not at all
  6684. *    support this type of function.
  6685. *
  6686. *   BUGS
  6687. * 
  6688. *   SEE ALSO
  6689. *     tdXExtGet(),tdXNofGet(),tdXSupportedGet(),tdXGescGet(),
  6690. *    tdXLibGet()
  6691. * 
  6692. ******************************************************************************
  6693. *
  6694. */
  6695. STRPTR __saveds ASM tdXNameGet(register __d1 TDenum type,register __d2 ULONG index) {
  6696.     TDenum mtype;
  6697.  
  6698.     // make a copy of type, d1 is a scratch register
  6699.     mtype=type;
  6700.  
  6701.     switch(mtype) {
  6702.         case TD_3XSAVE :
  6703.             if(tdlibinfos->lib3dinfos!=NULL) {
  6704.                 if(index>=0 && index<tdXNofGet(TD_3X)) {
  6705.                     if(tdlibinfos->lib3dinfos[index]->sups!=NULL) {
  6706.                         return(tdlibinfos->lib3dinfos[index]->name);
  6707.                     }
  6708.                 }
  6709.             }
  6710.             break;
  6711.         case TD_3XLOAD :
  6712.             if(tdlibinfos->lib3dinfos!=NULL) {
  6713.                 if(index>=0 && index<tdXNofGet(TD_3X)) {
  6714.                     if(tdlibinfos->lib3dinfos[index]->supl!=NULL) {
  6715.                         return(tdlibinfos->lib3dinfos[index]->name);
  6716.                     }
  6717.                 }
  6718.             }
  6719.             break;
  6720.         case TD_3X :
  6721.             if(tdlibinfos->lib3dinfos!=NULL) {
  6722.                 if(index>=0 && index<tdXNofGet(TD_3X)) {
  6723.                     return(tdlibinfos->lib3dinfos[index]->name);
  6724.                 }
  6725.             }
  6726.             break;
  6727.     }
  6728.     return(NULL);
  6729. }
  6730.  
  6731. /****** td.library/tdXSupportedGet ******************************************
  6732. * 
  6733. *   NAME    
  6734. *     tdXSupportedGet -- Returns an array of supported functions
  6735. *                       for a specific extension.
  6736. * 
  6737. *   SYNOPSIS
  6738. *    array = tdXSupportedGet(type,name)
  6739. *                            D1   D2
  6740. *
  6741. *    TDenum * tdXSupportedGet
  6742. *         ( TDEnum,STRPTR );
  6743. *
  6744. *   FUNCTION
  6745. *    You will get an array of all supported functions of the
  6746. *    extension.
  6747. *
  6748. *    This lists are READ_ONLY and only valid as
  6749. *    long as the library is opened.
  6750. * 
  6751. *   INPUTS
  6752. *    type     - Type of extension.
  6753. *    name     - Name of the extension.
  6754. *    
  6755. *   RESULT
  6756. *     array - A list of functions, terminated with TD_NOTHING,
  6757. *            or NULL if none.
  6758. *
  6759. *   EXAMPLE
  6760. *    array = tdXSupportedGet(TD_3XSAVE,"VRML");
  6761. *
  6762. *   NOTES
  6763. *
  6764. *   BUGS
  6765. * 
  6766. *   SEE ALSO
  6767. *     tdXExtGet(),tdXNofGet(),tdXNameGet(),tdXDescGet(),
  6768. *    tdXLibGet()
  6769. * 
  6770. ******************************************************************************
  6771. *
  6772. */
  6773. TDenum * __saveds ASM tdXSupportedGet(register __d1 TDenum type,register __d2 STRPTR name) {
  6774.     TDenum mtype;
  6775.     ULONG i;
  6776.  
  6777.     // make a copy of type, d1 is a scratch register
  6778.     mtype=type;
  6779.  
  6780.     switch(mtype) {
  6781.         case TD_3XSAVE :
  6782.         case TD_3XLOAD :
  6783.             if(tdlibinfos->lib3dinfos!=NULL && name!=NULL) {
  6784.                 i=0;
  6785.                 while(tdlibinfos->lib3dinfos[i]!=NULL) {
  6786.                     if(strcmp(tdlibinfos->lib3dinfos[i]->name,name)==0) {
  6787.                         if(mtype==TD_3XSAVE) {
  6788.                             return(tdlibinfos->lib3dinfos[i]->sups);
  6789.                         } else {
  6790.                             return(tdlibinfos->lib3dinfos[i]->supl);
  6791.                         }
  6792.                     }
  6793.                     i++;
  6794.                 }
  6795.             }
  6796.             break;
  6797.     }
  6798.     return(NULL);
  6799. }
  6800.  
  6801. /****** td.library/tdXDescGet ******************************************
  6802. * 
  6803. *   NAME    
  6804. *     tdXDescGet -- Returns a description for the type.
  6805. * 
  6806. *   SYNOPSIS
  6807. *    description = tdXDescGet(type)
  6808. *                             D1
  6809. *
  6810. *    STRPTR tdXDescGet
  6811. *         ( TDEnum );
  6812. *
  6813. *   FUNCTION
  6814. *    You will get a short description for the specific type.
  6815. *
  6816. *    This strings are READ_ONLY and only valid as
  6817. *    long as the library is opened.
  6818. * 
  6819. *   INPUTS
  6820. *    type     - Type of which you want a description.
  6821. *    
  6822. *   RESULT
  6823. *     description - A short description of type, or NULL if none.
  6824. *
  6825. *   EXAMPLE
  6826. *    description = tdXDescGet(TD_OJBECT);
  6827. *
  6828. *   NOTES
  6829. *
  6830. *   BUGS
  6831. * 
  6832. *   SEE ALSO
  6833. *     tdXExtGet(),tdXNofGet(),txXNameGet(),tdXSupportedGet(),
  6834. *    tdXLibGet()
  6835. * 
  6836. ******************************************************************************
  6837. *
  6838. */
  6839. STRPTR __saveds ASM tdXDescGet(register __d1 TDenum type) {
  6840.     TDenum mtype;
  6841.  
  6842.     // make a copy of type, d1 is a scratch register
  6843.     mtype=type;
  6844.  
  6845.     switch(mtype) {
  6846.         case TD_SPACE :
  6847.             return("Space");
  6848.         case TD_OBJECT :
  6849.             return("Object");
  6850.         case TD_MATERIAL :
  6851.             return("Material");
  6852.         case TD_SURFACE :
  6853.             return("Surface");
  6854.         case TD_TEXTURE :
  6855.             return("Texture");
  6856.     }
  6857.  
  6858.     return(NULL);
  6859. }
  6860.  
  6861. /****** td.library/tdXLibGet ******************************************
  6862. * 
  6863. *   NAME    
  6864. *     tdXLibGet -- Returns the name of the extension library.
  6865. * 
  6866. *   SYNOPSIS
  6867. *    library = tdXLibGet(type,name)
  6868. *                        D1   D2
  6869. *
  6870. *    STRPTR tdXLibGet
  6871. *         ( TDEnum,STRPTR );
  6872. *
  6873. *   FUNCTION
  6874. *    You will get the name of the extension library
  6875. *    with its name and type.
  6876. *
  6877. *    This strings are READ_ONLY and only valid as
  6878. *    long as the library is opened.
  6879. * 
  6880. *   INPUTS
  6881. *    type - Type of extension.
  6882. *    name - Name of the extension.
  6883. *    
  6884. *   RESULT
  6885. *     library - Name of the library, or NULL if none.
  6886. *
  6887. *   EXAMPLE
  6888. *    library = tdXLibGet(TD_3X,"VRML");
  6889. *
  6890. *   NOTES
  6891. *
  6892. *   BUGS
  6893. * 
  6894. *   SEE ALSO
  6895. *     tdXNameGet(),tdXNofGet(),tdXSupportedGet(),tdXDescGet(),
  6896. *    tdXExtGet()
  6897. * 
  6898. ******************************************************************************
  6899. *
  6900. */
  6901. STRPTR __saveds ASM tdXLibGet(register __d1 TDenum type,register __d2 STRPTR name) {
  6902.     TDenum mtype;
  6903.     ULONG i;
  6904.  
  6905.     // make a copy of type, d1 is a scratch register
  6906.     mtype=type;
  6907.  
  6908.     switch(mtype) {
  6909.         case TD_3X :
  6910.         case TD_3XSAVE :
  6911.         case TD_3XLOAD :
  6912.             if(tdlibinfos->lib3dinfos!=NULL && name!=NULL) {
  6913.                 i=0;
  6914.                 while(tdlibinfos->lib3dinfos[i]!=NULL) {
  6915.                     if(strcmp(tdlibinfos->lib3dinfos[i]->name,name)==0) {
  6916.                         return(tdlibinfos->lib3dinfos[i]->library);
  6917.                     }
  6918.                     i++;
  6919.                 }
  6920.             }
  6921.             break;
  6922.     }
  6923.  
  6924.     return(NULL);
  6925. }
  6926.  
  6927.  
  6928.  
  6929.  
  6930.  
  6931.  
  6932.  
  6933.  
  6934.  
  6935.  
  6936.  
  6937.  
  6938.  
  6939.  
  6940.  
  6941.  
  6942.  
  6943.  
  6944.  
  6945.  
  6946.  
  6947.  
  6948.  
  6949.  
  6950.  
  6951.  
  6952.  
  6953.  
  6954.  
  6955.  
  6956.  
  6957.  
  6958.  
  6959.  
  6960.  
  6961.  
  6962.  
  6963.  
  6964.  
  6965.  
  6966.  
  6967.  
  6968.  
  6969.  
  6970.  
  6971.  
  6972.  
  6973.  
  6974.  
  6975.  
  6976.  
  6977.  
  6978.  
  6979.  
  6980.  
  6981.  
  6982.  
  6983.  
  6984.  
  6985.  
  6986.  
  6987.  
  6988.  
  6989.  
  6990.  
  6991.  
  6992.  
  6993.  
  6994.  
  6995.  
  6996.  
  6997.  
  6998.  
  6999.  
  7000.  
  7001.  
  7002.  
  7003.  
  7004.  
  7005.  
  7006.  
  7007.  
  7008.  
  7009.  
  7010.  
  7011.  
  7012.  
  7013.  
  7014.  
  7015.  
  7016.  
  7017.  
  7018.  
  7019.  
  7020.  
  7021.  
  7022.  
  7023.  
  7024.  
  7025.  
  7026.  
  7027.  
  7028.  
  7029.  
  7030.  
  7031.  
  7032.  
  7033.  
  7034.  
  7035.  
  7036.  
  7037.  
  7038.  
  7039.  
  7040.  
  7041.  
  7042.  
  7043.  
  7044.  
  7045. /****** tdo.library/meshCameraLightDefaultSet ******************************************
  7046. * 
  7047. *   NAME    
  7048. *     meshCameraLightDefaultSet -- Set the camera and light to defaults.
  7049. * 
  7050. *   SYNOPSIS
  7051. *    error = meshCameraLightDefaultSet( meshhandle )
  7052. *                                       D1
  7053. *
  7054. *    ULONG meshCameraLightDefaultSet
  7055. *         ( ULONG )
  7056. *
  7057. *   FUNCTION
  7058. *    This function sets the camera and light properties as follows :
  7059. *    Camera looks to the center of the mesh and is positioned to view the whole mesh.
  7060. *    Light is positioned at the same point than the camera and gets a white color.
  7061. * 
  7062. *   INPUTS
  7063. *     meshhandle      - A valid handle of a mesh.
  7064. *    
  7065. *   RESULT
  7066. *     error - RCER_NOERROR    if all went well.
  7067. *            RCNOMESH     if the handle is not valid.
  7068. *
  7069. *   EXAMPLE
  7070. *    error= meshCameraLightDefaultSet(meshhandle);
  7071. *
  7072. *   NOTES
  7073. *    Camera and light will be used by some file formats only,
  7074. *    and for 2D or display functions.
  7075. *
  7076. *    If no values are set, this function will be called internally before
  7077. *    using functions which need a camera or a light source.
  7078. *
  7079. *   BUGS
  7080. * 
  7081. *   SEE ALSO
  7082. *     meshCameraPositionSet(),meshCameraLookAtSet(),
  7083. *    meshLightPositionSet(),meshLightColorSet()
  7084. * 
  7085. ******************************************************************************
  7086. *
  7087. */
  7088. ULONG __saveds ASM meshCameraLightDefaultSet(register __d1 ULONG meshhandle) {
  7089.     TTDOMesh *mesh=NULL;
  7090.   
  7091.     mesh=(TTDOMesh *) meshhandle;
  7092.     if(mesh==NULL) return(RCNOMESH);
  7093.     
  7094.     setCameraLight(mesh);
  7095.     
  7096.     return(RCNOERROR);
  7097. }
  7098.  
  7099. /****** tdo.library/meshCameraPositionSetdv ******************************************
  7100. * 
  7101. *   NAME    
  7102. *     meshCameraPositionSetdv -- Set the camera position.
  7103. * 
  7104. *   SYNOPSIS
  7105. *    error = meshCameraPositionSetdv( meshhandle,position )
  7106. *                                     D1          A0
  7107. *
  7108. *    ULONG meshCameraPositionSetdv
  7109. *         ( ULONG,TTDOVertexd * );
  7110. *
  7111. *   FUNCTION
  7112. *    The position of the camera will be set to the values passed by the
  7113. *    vertex structure.
  7114. * 
  7115. *   INPUTS
  7116. *     meshhandle      - A valid handle of a mesh.
  7117. *    position        - Pointer to a vertex structure containing the position information.
  7118. *    
  7119. *   RESULT
  7120. *     error - RCNOERROR    if all went well.
  7121. *`            RCNOMESH     if the handle is not valid.
  7122. *
  7123. *   EXAMPLE
  7124. *    error = meshCameraPositionSetdv(meshhandle,&myvertex);
  7125. *
  7126. *   NOTES
  7127. *    The camera will be used by some file formats only,
  7128. *    and for 2D or display functions.
  7129. *
  7130. *   BUGS
  7131. * 
  7132. *   SEE ALSO
  7133. *     meshCameraPositionGet(),meshCameraLookAtSet(),
  7134. *    meshCameraLookAtGet()
  7135. * 
  7136. ******************************************************************************
  7137. *
  7138. */
  7139. ULONG __saveds ASM meshCameraPositionSetdv(register __d1 ULONG meshhandle,
  7140.                                             register __a0 TTDOVertexd *position) {
  7141.     TTDOMesh        *mesh=NULL;
  7142.     TTDOVertexd    *mposition=NULL;
  7143.     
  7144.     // make a copy of position, a0 is a scratch register
  7145.     mposition=position;
  7146.   
  7147.     mesh=(TTDOMesh *) meshhandle;
  7148.     if(mesh==NULL) return(RCNOMESH);
  7149.     
  7150.     mesh->camera.position=(*mposition);
  7151.     
  7152.     return(RCNOERROR);
  7153. }
  7154.  
  7155. /****** tdo.library/meshCameraPositionSetfv ******************************************
  7156. * 
  7157. *   NAME    
  7158. *     meshCameraPositionSetfv -- Set the camera position.
  7159. * 
  7160. *   SYNOPSIS
  7161. *    error = meshCameraPositionSetfv( meshhandle,position )
  7162. *                                     D1          A0
  7163. *
  7164. *    ULONG meshCameraPositionSetfv
  7165. *         ( ULONG,TTDOVertexf * );
  7166. *
  7167. *   FUNCTION
  7168. *    The position of the camera will be set to the values passed by the
  7169. *    vertex structure.
  7170. * 
  7171. *   INPUTS
  7172. *     meshhandle      - A valid handle of a mesh.
  7173. *    position        - Pointer to a vertex structure containing the position information.
  7174. *    
  7175. *   RESULT
  7176. *     error - RCNOERROR    if all went well.
  7177. *`            RCNOMESH     if the handle is not valid.
  7178. *
  7179. *   EXAMPLE
  7180. *    error = meshCameraPositionSetfv(meshhandle,&myvertex);
  7181. *
  7182. *   NOTES
  7183. *    The camera will be used by some file formats only,
  7184. *    and for 2D or display functions.
  7185. *
  7186. *   BUGS
  7187. * 
  7188. *   SEE ALSO
  7189. *     meshCameraPositionGet(),meshCameraLookAtSet(),
  7190. *    meshCameraLookAtGet()
  7191. * 
  7192. ******************************************************************************
  7193. *
  7194. */
  7195. ULONG __saveds ASM meshCameraPositionSetfv(register __d1 ULONG meshhandle,
  7196.                                             register __a0 TTDOVertexf *position) {
  7197.     TTDOMesh        *mesh=NULL;
  7198.     TTDOVertexd    mposition;
  7199.     
  7200.     // make a copy of position, a0 is a scratch register
  7201.     mposition.x=position->x;
  7202.     mposition.y=position->y;
  7203.     mposition.z=position->z;
  7204.   
  7205.     mesh=(TTDOMesh *) meshhandle;
  7206.     if(mesh==NULL) return(RCNOMESH);
  7207.     
  7208.     mesh->camera.position=mposition;
  7209.     
  7210.     return(RCNOERROR);
  7211. }
  7212.  
  7213. /****** tdo.library/meshCameraPositionSet3da ******************************************
  7214. * 
  7215. *   NAME    
  7216. *     meshCameraPositionSet3da -- Set the camera position.
  7217. * 
  7218. *   SYNOPSIS
  7219. *    error = meshCameraPositionSet3da( meshhandle,position )
  7220. *                                      D1          A0
  7221. *
  7222. *    ULONG meshCameraPositionSet3da
  7223. *         ( ULONG,TTDODouble [3] );
  7224. *
  7225. *   FUNCTION
  7226. *    The position of the camera will be set to the values passed by the
  7227. *    double array.
  7228. * 
  7229. *   INPUTS
  7230. *     meshhandle      - A valid handle of a mesh.
  7231. *    position        - A double array containing the position information.
  7232. *    
  7233. *   RESULT
  7234. *     error - RCNOERROR    if all went well.
  7235. *`            RCNOMESH     if the handle is not valid.
  7236. *
  7237. *   EXAMPLE
  7238. *    error = meshCameraPositionSet3da(meshhandle,myvertex);
  7239. *
  7240. *   NOTES
  7241. *    The camera will be used by some file formats only,
  7242. *    and for 2D or display functions.
  7243. *
  7244. *   BUGS
  7245. * 
  7246. *   SEE ALSO
  7247. *     meshCameraPositionGet(),meshCameraLookAtSet(),
  7248. *    meshCameraLookAtGet()
  7249. * 
  7250. ******************************************************************************
  7251. *
  7252. */
  7253. ULONG __saveds ASM meshCameraPositionSet3da(register __d1 ULONG meshhandle,
  7254.                                             register __a0 TTDODouble position[3]) {
  7255.     TTDOMesh        *mesh=NULL;
  7256.     TTDOVertexd    mposition;
  7257.     
  7258.     // make a copy of position, a0 is a scratch register
  7259.     mposition.x=position[0];
  7260.     mposition.y=position[1];
  7261.     mposition.z=position[2];
  7262.   
  7263.     mesh=(TTDOMesh *) meshhandle;
  7264.     if(mesh==NULL) return(RCNOMESH);
  7265.     
  7266.     mesh->camera.position=mposition;
  7267.     
  7268.     return(RCNOERROR);
  7269. }
  7270.  
  7271. /****** tdo.library/meshCameraPositionSet3fa ******************************************
  7272. * 
  7273. *   NAME    
  7274. *     meshCameraPositionSet3fa -- Set the camera position.
  7275. * 
  7276. *   SYNOPSIS
  7277. *    error = meshCameraPositionSet3fa( meshhandle,position )
  7278. *                                      D1          A0
  7279. *
  7280. *    ULONG meshCameraPositionSet3fa
  7281. *         ( ULONG,TTDOFloat [3] );
  7282. *
  7283. *   FUNCTION
  7284. *    The position of the camera will be set to the values passed by the
  7285. *    float array.
  7286. * 
  7287. *   INPUTS
  7288. *     meshhandle      - A valid handle of a mesh.
  7289. *    position        - A float array containing the position information.
  7290. *    
  7291. *   RESULT
  7292. *     error - RCNOERROR    if all went well.
  7293. *`            RCNOMESH     if the handle is not valid.
  7294. *
  7295. *   EXAMPLE
  7296. *    error = meshCameraPositionSet3fa(meshhandle,myvertex);
  7297. *
  7298. *   NOTES
  7299. *    The camera will be used by some file formats only,
  7300. *    and for 2D or display functions.
  7301. *
  7302. *   BUGS
  7303. * 
  7304. *   SEE ALSO
  7305. *     meshCameraPositionGet(),meshCameraLookAtSet(),
  7306. *    meshCameraLookAtGet()
  7307. * 
  7308. ******************************************************************************
  7309. *
  7310. */
  7311. ULONG __saveds ASM meshCameraPositionSet3fa(register __d1 ULONG meshhandle,
  7312.                                             register __a0 TTDOFloat position[3]) {
  7313.     TTDOMesh        *mesh=NULL;
  7314.     TTDOVertexd    mposition;
  7315.     
  7316.     // make a copy of position, a0 is a scratch register
  7317.     mposition.x=position[0];
  7318.     mposition.y=position[1];
  7319.     mposition.z=position[2];
  7320.   
  7321.     mesh=(TTDOMesh *) meshhandle;
  7322.     if(mesh==NULL) return(RCNOMESH);
  7323.     
  7324.     mesh->camera.position=mposition;
  7325.     
  7326.     return(RCNOERROR);
  7327. }
  7328.  
  7329. /****** tdo.library/meshCameraPositionGetdv ******************************************
  7330. * 
  7331. *   NAME    
  7332. *     meshCameraPositionGetdv -- Get the position of the camera.
  7333. * 
  7334. *   SYNOPSIS
  7335. *    error = meshCameraPositionGetdv( meshhandle,position )
  7336. *                                     D1          A0
  7337. *
  7338. *    ULONG meshCameraPositionGetdv
  7339. *         ( ULONG,TTDOVertexd * );
  7340. *
  7341. *   FUNCTION
  7342. *    The position of the camera will be written in the passed vertex structure.
  7343. * 
  7344. *   INPUTS
  7345. *     meshhandle      - A valid handle of a mesh.
  7346. *    position        - Pointer to a vertex structure which will contain
  7347. *                      the position information.
  7348. *    
  7349. *   RESULT
  7350. *     error - RCNOERROR    if all went well.
  7351. *            RCNOMESH     if the handle is not valid.
  7352. *
  7353. *   EXAMPLE
  7354. *    error = meshCameraPositionGetdv(meshhandle,&myvertex);
  7355. *
  7356. *   NOTES
  7357. *    The camera will be used by some file formats only,
  7358. *    and for 2D or display functions.
  7359. *
  7360. *   BUGS
  7361. * 
  7362. *   SEE ALSO
  7363. *     meshCameraPositionSet(),meshCameraLookAtSet()
  7364. *    meshCameraLookAtGet()
  7365. * 
  7366. ******************************************************************************
  7367. *
  7368. */
  7369. ULONG __saveds ASM meshCameraPositionGetdv(register __d1 ULONG meshhandle,
  7370.                                             register __a0 TTDOVertexd *position) {
  7371.     TTDOMesh        *mesh=NULL;
  7372.     TTDOVertexd    *mposition=NULL;
  7373.     
  7374.     // make a copy of position, a0 is a scratch register
  7375.     mposition=position;
  7376.  
  7377.     mesh = (TTDOMesh *) meshhandle;
  7378.     if(mesh==NULL) return(RCNOMESH);
  7379.  
  7380.     (*mposition)=mesh->camera.position;
  7381.     
  7382.     return(RCNOERROR);
  7383. }
  7384.  
  7385. /****** tdo.library/meshCameraPositionGetfv ******************************************
  7386. * 
  7387. *   NAME    
  7388. *     meshCameraPositionGetfv -- Get the position of the camera.
  7389. * 
  7390. *   SYNOPSIS
  7391. *    error = meshCameraPositionGetfv( meshhandle,position )
  7392. *                                     D1          A0
  7393. *
  7394. *    ULONG meshCameraPositionGetfv
  7395. *         ( ULONG,TTDOVertexf * );
  7396. *
  7397. *   FUNCTION
  7398. *    The position of the camera will be written in the passed vertex structure.
  7399. * 
  7400. *   INPUTS
  7401. *     meshhandle      - A valid handle of a mesh.
  7402. *    position        - Pointer to a vertex structure which will contain
  7403. *                      the position information.
  7404. *    
  7405. *   RESULT
  7406. *     error - RCNOERROR    if all went well.
  7407. *            RCNOMESH     if the handle is not valid.
  7408. *
  7409. *   EXAMPLE
  7410. *    error = meshCameraPositionGetfv(meshhandle,&myvertex);
  7411. *
  7412. *   NOTES
  7413. *    The camera will be used by some file formats only,
  7414. *    and for 2D or display functions.
  7415. *
  7416. *   BUGS
  7417. * 
  7418. *   SEE ALSO
  7419. *     meshCameraPositionSet(),meshCameraLookAtSet()
  7420. *    meshCameraLookAtGet()
  7421. * 
  7422. ******************************************************************************
  7423. *
  7424. */
  7425. ULONG __saveds ASM meshCameraPositionGetfv(register __d1 ULONG meshhandle,
  7426.                                             register __a0 TTDOVertexf *position) {
  7427.     TTDOMesh        *mesh=NULL;
  7428.     TTDOVertexf    *mposition=NULL;
  7429.     
  7430.     // make a copy of position, a0 is a scratch register
  7431.     mposition=position;
  7432.  
  7433.     mesh = (TTDOMesh *) meshhandle;
  7434.     if(mesh==NULL) return(RCNOMESH);
  7435.  
  7436.     mposition->x=mesh->camera.position.x;
  7437.     mposition->y=mesh->camera.position.y;
  7438.     mposition->z=mesh->camera.position.z;
  7439.     
  7440.     return(RCNOERROR);
  7441. }
  7442.  
  7443. /****** tdo.library/meshCameraPositionGet3da ******************************************
  7444. * 
  7445. *   NAME    
  7446. *     meshCameraPositionGet3da -- Get the position of the camera.
  7447. * 
  7448. *   SYNOPSIS
  7449. *    error = meshCameraPositionGet3da( meshhandle,position )
  7450. *                                      D1          A0
  7451. *
  7452. *    ULONG meshCameraPositionGet3da
  7453. *         ( ULONG,TTDODouble [3] );
  7454. *
  7455. *   FUNCTION
  7456. *    The position of the camera will be written in the passed double array.
  7457. * 
  7458. *   INPUTS
  7459. *     meshhandle      - A valid handle of a mesh.
  7460. *    position        - A double array which will contain
  7461. *                      the position information.
  7462. *    
  7463. *   RESULT
  7464. *     error - RCNOERROR    if all went well.
  7465. *            RCNOMESH     if the handle is not valid.
  7466. *
  7467. *   EXAMPLE
  7468. *    error = meshCameraPositionGet3da(meshhandle,myvertex);
  7469. *
  7470. *   NOTES
  7471. *    The camera will be used by some file formats only,
  7472. *    and for 2D or display functions.
  7473. *
  7474. *   BUGS
  7475. * 
  7476. *   SEE ALSO
  7477. *     meshCameraPositionSet(),meshCameraLookAtSet()
  7478. *    meshCameraLookAtGet()
  7479. * 
  7480. ******************************************************************************
  7481. *
  7482. */
  7483. ULONG __saveds ASM meshCameraPositionGet3da(register __d1 ULONG meshhandle,
  7484.                                             register __a0 TTDODouble position[3]) {
  7485.     TTDOMesh        *mesh=NULL;
  7486.     TTDODouble        *mposition=NULL;
  7487.     
  7488.     // make a copy of position, a0 is a scratch register
  7489.     mposition=position;
  7490.  
  7491.     mesh = (TTDOMesh *) meshhandle;
  7492.     if(mesh==NULL) return(RCNOMESH);
  7493.  
  7494.     mposition[0]=mesh->camera.position.x;
  7495.     mposition[1]=mesh->camera.position.y;
  7496.     mposition[2]=mesh->camera.position.z;
  7497.     
  7498.     return(RCNOERROR);
  7499. }
  7500.  
  7501. /****** tdo.library/meshCameraPositionGet3fa ******************************************
  7502. * 
  7503. *   NAME    
  7504. *     meshCameraPositionGet3fa -- Get the position of the camera.
  7505. * 
  7506. *   SYNOPSIS
  7507. *    error = meshCameraPositionGet3fa( meshhandle,position )
  7508. *                                      D1          A0
  7509. *
  7510. *    ULONG meshCameraPositionGet3fa
  7511. *         ( ULONG,TTDOFloat [3] );
  7512. *
  7513. *   FUNCTION
  7514. *    The position of the camera will be written in the passed float array.
  7515. * 
  7516. *   INPUTS
  7517. *     meshhandle      - A valid handle of a mesh.
  7518. *    position        - A float array which will contain
  7519. *                      the position information.
  7520. *    
  7521. *   RESULT
  7522. *     error - RCNOERROR    if all went well.
  7523. *            RCNOMESH     if the handle is not valid.
  7524. *
  7525. *   EXAMPLE
  7526. *    error = meshCameraPositionGet3fa(meshhandle,myvertex);
  7527. *
  7528. *   NOTES
  7529. *    The camera will be used by some file formats only,
  7530. *    and for 2D or display functions.
  7531. *
  7532. *   BUGS
  7533. * 
  7534. *   SEE ALSO
  7535. *     meshCameraPositionSet(),meshCameraLookAtSet()
  7536. *    meshCameraLookAtGet()
  7537. * 
  7538. ******************************************************************************
  7539. *
  7540. */
  7541. ULONG __saveds ASM meshCameraPositionGet3fa(register __d1 ULONG meshhandle,
  7542.                                             register __a0 TTDOFloat position[3]) {
  7543.     TTDOMesh        *mesh=NULL;
  7544.     TTDOFloat        *mposition=NULL;
  7545.     
  7546.     // make a copy of position, a0 is a scratch register
  7547.     mposition=position;
  7548.  
  7549.     mesh = (TTDOMesh *) meshhandle;
  7550.     if(mesh==NULL) return(RCNOMESH);
  7551.  
  7552.     mposition[0]=mesh->camera.position.x;
  7553.     mposition[1]=mesh->camera.position.y;
  7554.     mposition[2]=mesh->camera.position.z;
  7555.     
  7556.     return(RCNOERROR);
  7557. }
  7558.  
  7559. /****** tdo.library/meshCameraLookAtSetdv ******************************************
  7560. * 
  7561. *   NAME    
  7562. *     meshCameraLookAtSetdv -- Set the camera its view point.
  7563. * 
  7564. *   SYNOPSIS
  7565. *    error = meshCameraLookAtSetdv( meshhandle,lookat )
  7566. *                                   D1          A0
  7567. *
  7568. *    ULONG meshCameraLookAtSetdv
  7569. *         ( ULONG,TTDOVertexd * );
  7570. *
  7571. *   FUNCTION
  7572. *    The view point of the camera will be set to the values passed by the
  7573. *    vertex structure.
  7574. * 
  7575. *   INPUTS
  7576. *     meshhandle      - A valid handle of a mesh.
  7577. *    lookat          - Pointer to a vertex structure containing the position information.
  7578. *    
  7579. *   RESULT
  7580. *     error - RCNOERROR    if all went well.
  7581. *            RCNOMESH     if the handle is not valid.
  7582. *
  7583. *   EXAMPLE
  7584. *    error = meshCameraLookAtSetdv(meshhandle,&myvertex);
  7585. *
  7586. *   NOTES
  7587. *    The camera will be used by some file formats only,
  7588. *    and for 2D or display functions.
  7589. *
  7590. *   BUGS
  7591. * 
  7592. *   SEE ALSO
  7593. *     meshCameraLookAtGet(),meshCameraPositionSet()
  7594. *    meshCameraPositionSet()
  7595. * 
  7596. ******************************************************************************
  7597. *
  7598. */
  7599. ULONG __saveds ASM meshCameraLookAtSetdv(register __d1 ULONG meshhandle,
  7600.                                         register __a0 TTDOVertexd *lookat) {
  7601.     TTDOMesh        *mesh=NULL;
  7602.     TTDOVertexd    *mlookat=NULL;
  7603.  
  7604.     // make a copy of lookat, a0 is a scratch register
  7605.     mlookat=lookat;
  7606.  
  7607.     mesh=(TTDOMesh *) meshhandle;
  7608.     if(mesh==NULL) return(RCNOMESH);
  7609.     
  7610.     mesh->camera.lookat=(*mlookat);
  7611.     
  7612.     return(RCNOERROR);
  7613. }
  7614.  
  7615. /****** tdo.library/meshCameraLookAtSetfv ******************************************
  7616. * 
  7617. *   NAME    
  7618. *     meshCameraLookAtSetfv -- Set the camera its view point.
  7619. * 
  7620. *   SYNOPSIS
  7621. *    error = meshCameraLookAtSetfv( meshhandle,lookat )
  7622. *                                   D1          A0
  7623. *
  7624. *    ULONG meshCameraLookAtSetfv
  7625. *         ( ULONG,TTDOVertexf * );
  7626. *
  7627. *   FUNCTION
  7628. *    The view point of the camera will be set to the values passed by the
  7629. *    vertex structure.
  7630. * 
  7631. *   INPUTS
  7632. *     meshhandle      - A valid handle of a mesh.
  7633. *    lookat          - Pointer to a vertex structure containing the position information.
  7634. *    
  7635. *   RESULT
  7636. *     error - RCNOERROR    if all went well.
  7637. *            RCNOMESH     if the handle is not valid.
  7638. *
  7639. *   EXAMPLE
  7640. *    error = meshCameraLookAtSetfv(meshhandle,&myvertex);
  7641. *
  7642. *   NOTES
  7643. *    The camera will be used by some file formats only,
  7644. *    and for 2D or display functions.
  7645. *
  7646. *   BUGS
  7647. * 
  7648. *   SEE ALSO
  7649. *     meshCameraLookAtGet(),meshCameraPositionSet()
  7650. *    meshCameraPositionSet()
  7651. * 
  7652. ******************************************************************************
  7653. *
  7654. */
  7655. ULONG __saveds ASM meshCameraLookAtSetfv(register __d1 ULONG meshhandle,
  7656.                                         register __a0 TTDOVertexf *lookat) {
  7657.     TTDOMesh        *mesh=NULL;
  7658.     TTDOVertexf    *mlookat=NULL;
  7659.  
  7660.     // make a copy of lookat, a0 is a scratch register
  7661.     mlookat=lookat;
  7662.  
  7663.     mesh=(TTDOMesh *) meshhandle;
  7664.     if(mesh==NULL) return(RCNOMESH);
  7665.     
  7666.     mesh->camera.lookat.x=mlookat->x;
  7667.     mesh->camera.lookat.y=mlookat->y;
  7668.     mesh->camera.lookat.z=mlookat->z;
  7669.     
  7670.     return(RCNOERROR);
  7671. }
  7672.  
  7673. /****** tdo.library/meshCameraLookAtSet3da ******************************************
  7674. * 
  7675. *   NAME    
  7676. *     meshCameraLookAtSet3da -- Set the camera its view point.
  7677. * 
  7678. *   SYNOPSIS
  7679. *    error = meshCameraLookAtSet3da( meshhandle,lookat )
  7680. *                                    D1          A0
  7681. *
  7682. *    ULONG meshCameraLookAtSet3da
  7683. *         ( ULONG,TTDODouble [3] );
  7684. *
  7685. *   FUNCTION
  7686. *    The view point of the camera will be set to the values passed by the
  7687. *    double array.
  7688. * 
  7689. *   INPUTS
  7690. *     meshhandle      - A valid handle of a mesh.
  7691. *    lookat          - A double array which contains the position information.
  7692. *    
  7693. *   RESULT
  7694. *     error - RCNOERROR    if all went well.
  7695. *            RCNOMESH     if the handle is not valid.
  7696. *
  7697. *   EXAMPLE
  7698. *    error = meshCameraLookAtSet3da(meshhandle,myvertex);
  7699. *
  7700. *   NOTES
  7701. *    The camera will be used by some file formats only,
  7702. *    and for 2D or display functions.
  7703. *
  7704. *   BUGS
  7705. * 
  7706. *   SEE ALSO
  7707. *     meshCameraLookAtGet(),meshCameraPositionSet()
  7708. *    meshCameraPositionSet()
  7709. * 
  7710. ******************************************************************************
  7711. *
  7712. */
  7713. ULONG __saveds ASM meshCameraLookAtSet3da(register __d1 ULONG meshhandle,
  7714.                                             register __a0 TTDODouble lookat[3]) {
  7715.     TTDOMesh        *mesh=NULL;
  7716.     TTDODouble        *mlookat=NULL;
  7717.  
  7718.     // make a copy of lookat, a0 is a scratch register
  7719.     mlookat=lookat;
  7720.  
  7721.     mesh=(TTDOMesh *) meshhandle;
  7722.     if(mesh==NULL) return(RCNOMESH);
  7723.     
  7724.     mesh->camera.lookat.x=mlookat[0];
  7725.     mesh->camera.lookat.y=mlookat[1];
  7726.     mesh->camera.lookat.z=mlookat[2];
  7727.     
  7728.     return(RCNOERROR);
  7729. }
  7730.  
  7731. /****** tdo.library/meshCameraLookAtSet3fa ******************************************
  7732. * 
  7733. *   NAME    
  7734. *     meshCameraLookAtSet3fa -- Set the camera its view point.
  7735. * 
  7736. *   SYNOPSIS
  7737. *    error = meshCameraLookAtSet3fa( meshhandle,lookat )
  7738. *                                    D1          A0
  7739. *
  7740. *    ULONG meshCameraLookAtSet3fa
  7741. *         ( ULONG,TTDOFloat [3] );
  7742. *
  7743. *   FUNCTION
  7744. *    The view point of the camera will be set to the values passed by the
  7745. *    float array.
  7746. * 
  7747. *   INPUTS
  7748. *     meshhandle      - A valid handle of a mesh.
  7749. *    lookat          - A float array which contains the position information.
  7750. *    
  7751. *   RESULT
  7752. *     error - RCNOERROR    if all went well.
  7753. *            RCNOMESH     if the handle is not valid.
  7754. *
  7755. *   EXAMPLE
  7756. *    error = meshCameraLookAtSet3fa(meshhandle,myvertex);
  7757. *
  7758. *   NOTES
  7759. *    The camera will be used by some file formats only,
  7760. *    and for 2D or display functions.
  7761. *
  7762. *   BUGS
  7763. * 
  7764. *   SEE ALSO
  7765. *     meshCameraLookAtGet(),meshCameraPositionSet()
  7766. *    meshCameraPositionSet()
  7767. * 
  7768. ******************************************************************************
  7769. *
  7770. */
  7771. ULONG __saveds ASM meshCameraLookAtSet3fa(register __d1 ULONG meshhandle,
  7772.                                             register __a0 TTDOFloat lookat[3]) {
  7773.     TTDOMesh        *mesh=NULL;
  7774.     TTDOFloat        *mlookat=NULL;
  7775.  
  7776.     // make a copy of lookat, a0 is a scratch register
  7777.     mlookat=lookat;
  7778.  
  7779.     mesh=(TTDOMesh *) meshhandle;
  7780.     if(mesh==NULL) return(RCNOMESH);
  7781.     
  7782.     mesh->camera.lookat.x=mlookat[0];
  7783.     mesh->camera.lookat.y=mlookat[1];
  7784.     mesh->camera.lookat.z=mlookat[2];
  7785.     
  7786.     return(RCNOERROR);
  7787. }
  7788.  
  7789. /****** tdo.library/meshCameraLookAtGetdv ******************************************
  7790. * 
  7791. *   NAME    
  7792. *     meshCameraLookAtGetdv -- Get the view point of the camera.
  7793. * 
  7794. *   SYNOPSIS
  7795. *    error = meshCameraLookAtGetdv( meshhandle,lookat )
  7796. *                                   D1          A0
  7797. *
  7798. *    ULONG meshCameraLookAtGetdv
  7799. *         ( ULONG,TTDOVertexd * );
  7800. *
  7801. *   FUNCTION
  7802. *    The view point of the camera will be written in the passed vertex structure.
  7803. * 
  7804. *   INPUTS
  7805. *     meshhandle      - A valid handle of a mesh.
  7806. *    lookat          - Pointer to a vertex structure which will contain
  7807. *                      the position information.
  7808. *    
  7809. *   RESULT
  7810. *     error - RCNOERROR    if all went well.
  7811. *            RCNOMESH     if the handle is not valid.
  7812. *
  7813. *   EXAMPLE
  7814. *    error = meshCameraLookAtGetdv(meshhandle,&myvertex);
  7815. *
  7816. *   NOTES
  7817. *    The camera will be used by some file formats only,
  7818. *    and for 2D or display functions.
  7819. *
  7820. *   BUGS
  7821. * 
  7822. *   SEE ALSO
  7823. *     meshCameraLookAtSet(),meshCameraPositionSet()
  7824. *    meshCameraPositionGet()
  7825. * 
  7826. ******************************************************************************
  7827. *
  7828. */
  7829. ULONG __saveds ASM meshCameraLookAtGetdv(register __d1 ULONG meshhandle,
  7830.                                         register __a0 TTDOVertexd *lookat) {
  7831.     TTDOMesh        *mesh=NULL;
  7832.     TTDOVertexd    *mlookat=NULL;
  7833.     
  7834.     // make a copy of lookat, a0 is a scratch register
  7835.     mlookat=lookat;
  7836.   
  7837.     mesh=(TTDOMesh *) meshhandle;
  7838.     if(mesh==NULL) return(RCNOMESH);
  7839.  
  7840.     (*mlookat)=mesh->camera.lookat;
  7841.     
  7842.     return(RCNOERROR);
  7843. }
  7844.  
  7845. /****** tdo.library/meshCameraLookAtGetfv ******************************************
  7846. * 
  7847. *   NAME    
  7848. *     meshCameraLookAtGetfv -- Get the view point of the camera.
  7849. * 
  7850. *   SYNOPSIS
  7851. *    error = meshCameraLookAtGetfv( meshhandle,lookat )
  7852. *                                   D1          A0
  7853. *
  7854. *    ULONG meshCameraLookAtGetfv
  7855. *         ( ULONG,TTDOVertexf * );
  7856. *
  7857. *   FUNCTION
  7858. *    The view point of the camera will be written in the passed vertex structure.
  7859. * 
  7860. *   INPUTS
  7861. *     meshhandle      - A valid handle of a mesh.
  7862. *    lookat          - Pointer to a vertex structure which will contain
  7863. *                      the position information.
  7864. *    
  7865. *   RESULT
  7866. *     error - RCNOERROR    if all went well.
  7867. *            RCNOMESH     if the handle is not valid.
  7868. *
  7869. *   EXAMPLE
  7870. *    error = meshCameraLookAtGetfv(meshhandle,&myvertex);
  7871. *
  7872. *   NOTES
  7873. *    The camera will be used by some file formats only,
  7874. *    and for 2D or display functions.
  7875. *
  7876. *   BUGS
  7877. * 
  7878. *   SEE ALSO
  7879. *     meshCameraLookAtSet(),meshCameraPositionSet()
  7880. *    meshCameraPositionGet()
  7881. * 
  7882. ******************************************************************************
  7883. *
  7884. */
  7885. ULONG __saveds ASM meshCameraLookAtGetfv(register __d1 ULONG meshhandle,
  7886.                                             register __a0 TTDOVertexf *lookat) {
  7887.     TTDOMesh        *mesh=NULL;
  7888.     TTDOVertexf    *mlookat=NULL;
  7889.     
  7890.     // make a copy of lookat, a0 is a scratch register
  7891.     mlookat=lookat;
  7892.   
  7893.     mesh=(TTDOMesh *) meshhandle;
  7894.     if(mesh==NULL) return(RCNOMESH);
  7895.  
  7896.     mlookat->x=mesh->camera.lookat.x;
  7897.     mlookat->y=mesh->camera.lookat.y;
  7898.     mlookat->z=mesh->camera.lookat.z;
  7899.     
  7900.     return(RCNOERROR);
  7901. }
  7902.  
  7903. /****** tdo.library/meshCameraLookAtGet3da ******************************************
  7904. * 
  7905. *   NAME    
  7906. *     meshCameraLookAtGet3da -- Get the view point of the camera.
  7907. * 
  7908. *   SYNOPSIS
  7909. *    error = meshCameraLookAtGet3da( meshhandle,lookat )
  7910. *                                    D1          A0
  7911. *
  7912. *    ULONG meshCameraLookAtGet3da
  7913. *         ( ULONG,TTDODouble [3] );
  7914. *
  7915. *   FUNCTION
  7916. *    The view point of the camera will be written in the passed double array.
  7917. * 
  7918. *   INPUTS
  7919. *     meshhandle      - A valid handle of a mesh.
  7920. *    lookat          - A double array which will contain
  7921. *                      the position information.
  7922. *    
  7923. *   RESULT
  7924. *     error - RCNOERROR    if all went well.
  7925. *            RCNOMESH     if the handle is not valid.
  7926. *
  7927. *   EXAMPLE
  7928. *    error = meshCameraLookAtGet3da(meshhandle,myvertex);
  7929. *
  7930. *   NOTES
  7931. *    The camera will be used by some file formats only,
  7932. *    and for 2D or display functions.
  7933. *
  7934. *   BUGS
  7935. * 
  7936. *   SEE ALSO
  7937. *     meshCameraLookAtSet(),meshCameraPositionSet()
  7938. *    meshCameraPositionGet()
  7939. * 
  7940. ******************************************************************************
  7941. *
  7942. */
  7943. ULONG __saveds ASM meshCameraLookAtGet3da(register __d1 ULONG meshhandle,
  7944.                                             register __a0 TTDODouble lookat[3]) {
  7945.     TTDOMesh        *mesh=NULL;
  7946.     TTDODouble        *mlookat=NULL;
  7947.     
  7948.     // make a copy of lookat, a0 is a scratch register
  7949.     mlookat=lookat;
  7950.   
  7951.     mesh=(TTDOMesh *) meshhandle;
  7952.     if(mesh==NULL) return(RCNOMESH);
  7953.  
  7954.     mlookat[0]=mesh->camera.lookat.x;
  7955.     mlookat[1]=mesh->camera.lookat.y;
  7956.     mlookat[2]=mesh->camera.lookat.z;
  7957.     
  7958.     return(RCNOERROR);
  7959. }
  7960.  
  7961. /****** tdo.library/meshCameraLookAtGet3fa ******************************************
  7962. * 
  7963. *   NAME    
  7964. *     meshCameraLookAtGet3fa -- Get the view point of the camera.
  7965. * 
  7966. *   SYNOPSIS
  7967. *    error = meshCameraLookAtGet3fa( meshhandle,lookat )
  7968. *                                    D1          A0
  7969. *
  7970. *    ULONG meshCameraLookAtGet3fa
  7971. *         ( ULONG,TTDOFloat [3] );
  7972. *
  7973. *   FUNCTION
  7974. *    The view point of the camera will be written in the passed float array.
  7975. * 
  7976. *   INPUTS
  7977. *     meshhandle      - A valid handle of a mesh.
  7978. *    lookat          - A float array which will contain
  7979. *                      the position information.
  7980. *    
  7981. *   RESULT
  7982. *     error - RCNOERROR    if all went well.
  7983. *            RCNOMESH     if the handle is not valid.
  7984. *
  7985. *   EXAMPLE
  7986. *    error = meshCameraLookAtGet3fa(meshhandle,myvertex);
  7987. *
  7988. *   NOTES
  7989. *    The camera will be used by some file formats only,
  7990. *    and for 2D or display functions.
  7991. *
  7992. *   BUGS
  7993. * 
  7994. *   SEE ALSO
  7995. *     meshCameraLookAtSet(),meshCameraPositionSet()
  7996. *    meshCameraPositionGet()
  7997. * 
  7998. ******************************************************************************
  7999. *
  8000. */
  8001. ULONG __saveds ASM meshCameraLookAtGet3fa(register __d1 ULONG meshhandle,
  8002.                                             register __a0 TTDOFloat lookat[3]) {
  8003.     TTDOMesh        *mesh=NULL;
  8004.     TTDOFloat        *mlookat=NULL;
  8005.     
  8006.     // make a copy of lookat, a0 is a scratch register
  8007.     mlookat=lookat;
  8008.   
  8009.     mesh=(TTDOMesh *) meshhandle;
  8010.     if(mesh==NULL) return(RCNOMESH);
  8011.  
  8012.     mlookat[0]=mesh->camera.lookat.x;
  8013.     mlookat[1]=mesh->camera.lookat.y;
  8014.     mlookat[2]=mesh->camera.lookat.z;
  8015.     
  8016.     return(RCNOERROR);
  8017. }
  8018.  
  8019. /****** tdo.library/meshLightPositionSetdv ******************************************
  8020. * 
  8021. *   NAME    
  8022. *     meshLightPositionSetdv -- Set the light source its position.
  8023. * 
  8024. *   SYNOPSIS
  8025. *    error = meshLightPositionSetdv( meshhandle,position )
  8026. *                                    D1          A0
  8027. *
  8028. *    ULONG meshLightPositionSetdv
  8029. *         ( ULONG,TTDOVertexd * );
  8030. *
  8031. *   FUNCTION
  8032. *    The position of the light source will be set to the values passed by the
  8033. *    vertex structure.
  8034. * 
  8035. *   INPUTS
  8036. *     meshhandle      - A valid handle of a mesh.
  8037. *    position        - Pointer to a vertex structure containing the position information.
  8038. *    
  8039. *   RESULT
  8040. *     error - RCNOERROR    if all went well.
  8041. *            RCNOMESH     if the handle is not valid.
  8042. *
  8043. *   EXAMPLE
  8044. *    error = meshLightPositionSetdv(meshhandle,&myvertex);
  8045. *
  8046. *   NOTES
  8047. *    The light will be used by some file formats only,
  8048. *    and for 2D or display functions.
  8049. *
  8050. *   BUGS
  8051. * 
  8052. *   SEE ALSO
  8053. *     meshLightPositionGet(),meshLightColorSet()
  8054. *    meshLightColorGet()
  8055. * 
  8056. ******************************************************************************
  8057. *
  8058. */
  8059. ULONG __saveds ASM meshLightPositionSetdv(register __d1 ULONG meshhandle,
  8060.                                             register __a0 TTDOVertexd *position) {
  8061.     TTDOMesh        *mesh=NULL;
  8062.     TTDOVertexd        *mposition=NULL;
  8063.  
  8064.     // make a copy of position, a0 is a scratch register
  8065.     mposition=position;
  8066.  
  8067.     mesh=(TTDOMesh *) meshhandle;
  8068.     if(mesh==NULL) return(RCNOMESH);
  8069.     
  8070.     mesh->light.position=(*mposition);
  8071.     
  8072.     return(RCNOERROR);
  8073. }
  8074.  
  8075. /****** tdo.library/meshLightPositionSetfv ******************************************
  8076. * 
  8077. *   NAME    
  8078. *     meshLightPositionSetfv -- Set the light source its position.
  8079. * 
  8080. *   SYNOPSIS
  8081. *    error = meshLightPositionSetfv( meshhandle,position )
  8082. *                                    D1          A0
  8083. *
  8084. *    ULONG meshLightPositionSetfv
  8085. *         ( ULONG,TTDOVertexf * );
  8086. *
  8087. *   FUNCTION
  8088. *    The position of the light source will be set to the values passed by the
  8089. *    vertex structure.
  8090. * 
  8091. *   INPUTS
  8092. *     meshhandle      - A valid handle of a mesh.
  8093. *    position        - Pointer to a vertex structure containing the position information.
  8094. *    
  8095. *   RESULT
  8096. *     error - RCNOERROR    if all went well.
  8097. *            RCNOMESH     if the handle is not valid.
  8098. *
  8099. *   EXAMPLE
  8100. *    error = meshLightPositionSetfv(meshhandle,&myvertex);
  8101. *
  8102. *   NOTES
  8103. *    The light will be used by some file formats only,
  8104. *    and for 2D or display functions.
  8105. *
  8106. *   BUGS
  8107. * 
  8108. *   SEE ALSO
  8109. *     meshLightPositionGet(),meshLightColorSet()
  8110. *    meshLightColorGet()
  8111. * 
  8112. ******************************************************************************
  8113. *
  8114. */
  8115. ULONG __saveds ASM meshLightPositionSetfv(register __d1 ULONG meshhandle,
  8116.                                             register __a0 TTDOVertexf *position) {
  8117.     TTDOMesh        *mesh=NULL;
  8118.     TTDOVertexf    *mposition=NULL;
  8119.  
  8120.     // make a copy of position, a0 is a scratch register
  8121.     mposition=position;
  8122.  
  8123.     mesh=(TTDOMesh *) meshhandle;
  8124.     if(mesh==NULL) return(RCNOMESH);
  8125.     
  8126.     mesh->light.position.x=mposition->x;
  8127.     mesh->light.position.y=mposition->y;
  8128.     mesh->light.position.z=mposition->z;
  8129.     
  8130.     return(RCNOERROR);
  8131. }
  8132.  
  8133. /****** tdo.library/meshLightPositionSet3da ******************************************
  8134. * 
  8135. *   NAME    
  8136. *     meshLightPositionSet3da -- Set the light source its position.
  8137. * 
  8138. *   SYNOPSIS
  8139. *    error = meshLightPositionSet3da( meshhandle,position )
  8140. *                                     D1          A0
  8141. *
  8142. *    ULONG meshLightPositionSet3da
  8143. *         ( ULONG,TTDODouble [3] );
  8144. *
  8145. *   FUNCTION
  8146. *    The position of the light source will be set to the values passed by the
  8147. *    double array.
  8148. * 
  8149. *   INPUTS
  8150. *     meshhandle      - A valid handle of a mesh.
  8151. *    position        - A double array which containis the position information.
  8152. *    
  8153. *   RESULT
  8154. *     error - RCNOERROR    if all went well.
  8155. *            RCNOMESH     if the handle is not valid.
  8156. *
  8157. *   EXAMPLE
  8158. *    error = meshLightPositionSet3da(meshhandle,myvertex);
  8159. *
  8160. *   NOTES
  8161. *    The light will be used by some file formats only,
  8162. *    and for 2D or display functions.
  8163. *
  8164. *   BUGS
  8165. * 
  8166. *   SEE ALSO
  8167. *     meshLightPositionGet(),meshLightColorSet()
  8168. *    meshLightColorGet()
  8169. * 
  8170. ******************************************************************************
  8171. *
  8172. */
  8173. ULONG __saveds ASM meshLightPositionSet3da(register __d1 ULONG meshhandle,
  8174.                                             register __a0 TTDODouble  position[3]) {
  8175.     TTDOMesh        *mesh=NULL;
  8176.     TTDODouble        *mposition=NULL;
  8177.  
  8178.     // make a copy of position, a0 is a scratch register
  8179.     mposition=position;
  8180.  
  8181.     mesh=(TTDOMesh *) meshhandle;
  8182.     if(mesh==NULL) return(RCNOMESH);
  8183.     
  8184.     mesh->light.position.x=mposition[0];
  8185.     mesh->light.position.y=mposition[1];
  8186.     mesh->light.position.z=mposition[2];
  8187.     
  8188.     return(RCNOERROR);
  8189. }
  8190.  
  8191. /****** tdo.library/meshLightPositionSet3fa ******************************************
  8192. * 
  8193. *   NAME    
  8194. *     meshLightPositionSet3fa -- Set the light source its position.
  8195. * 
  8196. *   SYNOPSIS
  8197. *    error = meshLightPositionSet3fa( meshhandle,position )
  8198. *                                     D1          A0
  8199. *
  8200. *    ULONG meshLightPositionSet3fa
  8201. *         ( ULONG,TTDOFloat [3] );
  8202. *
  8203. *   FUNCTION
  8204. *    The position of the light source will be set to the values passed by the
  8205. *    float array.
  8206. * 
  8207. *   INPUTS
  8208. *     meshhandle      - A valid handle of a mesh.
  8209. *    position        - A float array which containis the position information.
  8210. *    
  8211. *   RESULT
  8212. *     error - RCNOERROR    if all went well.
  8213. *            RCNOMESH     if the handle is not valid.
  8214. *
  8215. *   EXAMPLE
  8216. *    error = meshLightPositionSet3fa(meshhandle,myvertex);
  8217. *
  8218. *   NOTES
  8219. *    The light will be used by some file formats only,
  8220. *    and for 2D or display functions.
  8221. *
  8222. *   BUGS
  8223. * 
  8224. *   SEE ALSO
  8225. *     meshLightPositionGet(),meshLightColorSet()
  8226. *    meshLightColorGet()
  8227. * 
  8228. ******************************************************************************
  8229. *
  8230. */
  8231. ULONG __saveds ASM meshLightPositionSet3fa(register __d1 ULONG meshhandle,
  8232.                                             register __a0 TTDOFloat  position[3]) {
  8233.     TTDOMesh        *mesh=NULL;
  8234.     TTDOFloat        *mposition=NULL;
  8235.  
  8236.     // make a copy of position, a0 is a scratch register
  8237.     mposition=position;
  8238.  
  8239.     mesh=(TTDOMesh *) meshhandle;
  8240.     if(mesh==NULL) return(RCNOMESH);
  8241.     
  8242.     mesh->light.position.x=mposition[0];
  8243.     mesh->light.position.y=mposition[1];
  8244.     mesh->light.position.z=mposition[2];
  8245.     
  8246.     return(RCNOERROR);
  8247. }
  8248.  
  8249. /****** tdo.library/meshLightPositionGetdv ******************************************
  8250. * 
  8251. *   NAME    
  8252. *     meshLightPositionGetdv -- Get the position of the light source.
  8253. * 
  8254. *   SYNOPSIS
  8255. *    error = meshLightPositionGetdv( meshhandle,position )
  8256. *                                    D1          A0
  8257. *
  8258. *    ULONG meshLightPositionGetdv
  8259. *         ( ULONG,TTDOVertexd * );
  8260. *
  8261. *   FUNCTION
  8262. *    The position of the light source will be written in the passed vertex structure.
  8263. * 
  8264. *   INPUTS
  8265. *     meshhandle      - A valid handle of a mesh.
  8266. *    position        - Pointer to a vertex structure which will contain
  8267. *                      the position information.
  8268. *    
  8269. *   RESULT
  8270. *     error - RCNOERROR    if all went well.
  8271. *            RCNOMESH     if the handle is not valid.
  8272. *
  8273. *   EXAMPLE
  8274. *    error = meshLightPositionGetdv(meshhandle,&myvertex);
  8275. *
  8276. *   NOTES
  8277. *    The light will be used by some file formats only,
  8278. *    and for 2D or display functions.
  8279. *
  8280. *   BUGS
  8281. * 
  8282. *   SEE ALSO
  8283. *     meshLightPositionSet(),meshLightColorSet()
  8284. *    meshLightColorGet()
  8285. * 
  8286. ******************************************************************************
  8287. *
  8288. */
  8289. ULONG __saveds ASM meshLightPositionGetdv(register __d1 ULONG meshhandle,
  8290.                                             register __a0 TTDOVertexd *position) {
  8291.     TTDOMesh        *mesh=NULL;
  8292.     TTDOVertexd    *mposition=NULL;
  8293.     
  8294.     // make a copy of position, a0 is a scratch register
  8295.     mposition=position;
  8296.   
  8297.     mesh=(TTDOMesh *) meshhandle;
  8298.     if(mesh==NULL) return(RCNOMESH);
  8299.  
  8300.     (*mposition)=mesh->light.position;
  8301.     
  8302.     return(RCNOERROR);
  8303. }
  8304.  
  8305. /****** tdo.library/meshLightPositionGetfv ******************************************
  8306. * 
  8307. *   NAME    
  8308. *     meshLightPositionGetfv -- Get the position of the light source.
  8309. * 
  8310. *   SYNOPSIS
  8311. *    error = meshLightPositionGetfv( meshhandle,position )
  8312. *                                    D1          A0
  8313. *
  8314. *    ULONG meshLightPositionGetfv
  8315. *         ( ULONG,TTDOVertexf * );
  8316. *
  8317. *   FUNCTION
  8318. *    The position of the light source will be written in the passed vertex structure.
  8319. * 
  8320. *   INPUTS
  8321. *     meshhandle      - A valid handle of a mesh.
  8322. *    position        - Pointer to a vertex structure which will contain
  8323. *                      the position information.
  8324. *    
  8325. *   RESULT
  8326. *     error - RCNOERROR    if all went well.
  8327. *            RCNOMESH     if the handle is not valid.
  8328. *
  8329. *   EXAMPLE
  8330. *    error = meshLightPositionGetfv(meshhandle,&myvertex);
  8331. *
  8332. *   NOTES
  8333. *    The light will be used by some file formats only,
  8334. *    and for 2D or display functions.
  8335. *
  8336. *   BUGS
  8337. * 
  8338. *   SEE ALSO
  8339. *     meshLightPositionSet(),meshLightColorSet()
  8340. *    meshLightColorGet()
  8341. * 
  8342. ******************************************************************************
  8343. *
  8344. */
  8345. ULONG __saveds ASM meshLightPositionGetfv(register __d1 ULONG meshhandle,
  8346.                                             register __a0 TTDOVertexf *position) {
  8347.     TTDOMesh        *mesh=NULL;
  8348.     TTDOVertexf    *mposition=NULL;
  8349.     
  8350.     // make a copy of position, a0 is a scratch register
  8351.     mposition=position;
  8352.   
  8353.     mesh=(TTDOMesh *) meshhandle;
  8354.     if(mesh==NULL) return(RCNOMESH);
  8355.  
  8356.     mposition->x=mesh->light.position.x;
  8357.     mposition->y=mesh->light.position.y;
  8358.     mposition->z=mesh->light.position.z;
  8359.     
  8360.     return(RCNOERROR);
  8361. }
  8362.  
  8363. /****** tdo.library/meshLightPositionGet3da ******************************************
  8364. * 
  8365. *   NAME    
  8366. *     meshLightPositionGet3da -- Get the position of the light source.
  8367. * 
  8368. *   SYNOPSIS
  8369. *    error = meshLightPositionGet3da( meshhandle,position )
  8370. *                                     D1          A0
  8371. *
  8372. *    ULONG meshLightPositionGet3da
  8373. *         ( ULONG,TTDODouble [3] );
  8374. *
  8375. *   FUNCTION
  8376. *    The position of the light source will be written in the passed double array.
  8377. * 
  8378. *   INPUTS
  8379. *     meshhandle      - A valid handle of a mesh.
  8380. *    position        - A double array which will contain
  8381. *                      the position information.
  8382. *    
  8383. *   RESULT
  8384. *     error - RCNOERROR    if all went well.
  8385. *            RCNOMESH     if the handle is not valid.
  8386. *
  8387. *   EXAMPLE
  8388. *    error = meshLightPositionGet3da(meshhandle,myvertex);
  8389. *
  8390. *   NOTES
  8391. *    The light will be used by some file formats only,
  8392. *    and for 2D or display functions.
  8393. *
  8394. *   BUGS
  8395. * 
  8396. *   SEE ALSO
  8397. *     meshLightPositionSet(),meshLightColorSet()
  8398. *    meshLightColorGet()
  8399. * 
  8400. ******************************************************************************
  8401. *
  8402. */
  8403. ULONG __saveds ASM meshLightPositionGet3da(register __d1 ULONG meshhandle,
  8404.                                             register __a0 TTDODouble position[3]) {
  8405.     TTDOMesh        *mesh=NULL;
  8406.     TTDODouble        *mposition=NULL;
  8407.     
  8408.     // make a copy of position, a0 is a scratch register
  8409.     mposition=position;
  8410.   
  8411.     mesh=(TTDOMesh *) meshhandle;
  8412.     if(mesh==NULL) return(RCNOMESH);
  8413.  
  8414.     mposition[0]=mesh->light.position.x;
  8415.     mposition[1]=mesh->light.position.y;
  8416.     mposition[2]=mesh->light.position.z;
  8417.     
  8418.     return(RCNOERROR);
  8419. }
  8420.  
  8421. /****** tdo.library/meshLightPositionGet3fa ******************************************
  8422. * 
  8423. *   NAME    
  8424. *     meshLightPositionGet3fa -- Get the position of the light source.
  8425. * 
  8426. *   SYNOPSIS
  8427. *    error = meshLightPositionGet3fa( meshhandle,position )
  8428. *                                     D1          A0
  8429. *
  8430. *    ULONG meshLightPositionGet3fa
  8431. *         ( ULONG,TTDOFloat [3] );
  8432. *
  8433. *   FUNCTION
  8434. *    The position of the light source will be written in the passed float array.
  8435. * 
  8436. *   INPUTS
  8437. *     meshhandle      - A valid handle of a mesh.
  8438. *    position        - A float array which will contain
  8439. *                      the position information.
  8440. *    
  8441. *   RESULT
  8442. *     error - RCNOERROR    if all went well.
  8443. *            RCNOMESH     if the handle is not valid.
  8444. *
  8445. *   EXAMPLE
  8446. *    error = meshLightPositionGet3fa(meshhandle,myvertex);
  8447. *
  8448. *   NOTES
  8449. *    The light will be used by some file formats only,
  8450. *    and for 2D or display functions.
  8451. *
  8452. *   BUGS
  8453. * 
  8454. *   SEE ALSO
  8455. *     meshLightPositionSet(),meshLightColorSet()
  8456. *    meshLightColorGet()
  8457. * 
  8458. ******************************************************************************
  8459. *
  8460. */
  8461. ULONG __saveds ASM meshLightPositionGet3fa(register __d1 ULONG meshhandle,
  8462.                                             register __a0 TTDOFloat position[3]) {
  8463.     TTDOMesh        *mesh=NULL;
  8464.     TTDOFloat        *mposition=NULL;
  8465.     
  8466.     // make a copy of position, a0 is a scratch register
  8467.     mposition=position;
  8468.   
  8469.     mesh=(TTDOMesh *) meshhandle;
  8470.     if(mesh==NULL) return(RCNOMESH);
  8471.  
  8472.     mposition[0]=mesh->light.position.x;
  8473.     mposition[1]=mesh->light.position.y;
  8474.     mposition[2]=mesh->light.position.z;
  8475.     
  8476.     return(RCNOERROR);
  8477. }
  8478.  
  8479. /****** tdo.library/meshLightColorSetubc ******************************************
  8480. * 
  8481. *   NAME    
  8482. *     meshLightColorSetubc -- Set the light source its color.
  8483. * 
  8484. *   SYNOPSIS
  8485. *    error = meshLightColorSetubc( meshhandle,color )
  8486. *                                  D1          A0
  8487. *
  8488. *    ULONG meshLightColorSetubc
  8489. *         ( ULONG,TTDOColorub * );
  8490. *
  8491. *   FUNCTION
  8492. *    The color of the light source will be set to the values passed by the
  8493. *    color structure.
  8494. * 
  8495. *   INPUTS
  8496. *     meshhandle      - A valid handle of a mesh.
  8497. *    color           - Pointer to a color structure containing the color information.
  8498. *    
  8499. *   RESULT
  8500. *     error - RCNOERROR    if all went well.
  8501. *            RCNOMESH     if the handle is not valid.
  8502. *
  8503. *   EXAMPLE
  8504. *    error = meshLightColorSetubc(meshhandle,&mycolor);
  8505. *
  8506. *   NOTES
  8507. *    The light will be used by some file formats only,
  8508. *    and for 2D or display functions.
  8509. *
  8510. *   BUGS
  8511. * 
  8512. *   SEE ALSO
  8513. *     meshLightColorGet(),meshLightPositionSet()
  8514. *    meshLightPositionGet()
  8515. * 
  8516. ******************************************************************************
  8517. *
  8518. */
  8519. ULONG __saveds ASM meshLightColorSetubc(register __d1 ULONG meshhandle,
  8520.                                          register __a0 TTDOColorub *color) {
  8521.     TTDOMesh        *mesh=NULL;
  8522.     TTDOColorub    *mcolor=NULL;
  8523.     
  8524.     // make a copy of color, a0 is a scratch register
  8525.     mcolor=color;
  8526.   
  8527.     mesh=(TTDOMesh *) meshhandle;
  8528.     if(mesh==NULL) return(RCNOMESH);
  8529.     
  8530.     mesh->light.color=(*mcolor);
  8531.  
  8532.     return(RCNOERROR);
  8533. }
  8534.  
  8535. /****** tdo.library/meshLightColorGetubc ******************************************
  8536. * 
  8537. *   NAME    
  8538. *     meshLightColorGetubc -- Get the color of the light source.
  8539. * 
  8540. *   SYNOPSIS
  8541. *    error = meshLightColorGetubc( meshhandle,color )
  8542. *                                  D1          A0
  8543. *
  8544. *    ULONG meshLightColorGetubc
  8545. *         ( ULONG,TTDOColorub * );
  8546. *
  8547. *   FUNCTION
  8548. *    The color of the light source will be written in the passed color structure.
  8549. * 
  8550. *   INPUTS
  8551. *     meshhandle      - A valid handle of a mesh.
  8552. *    color           - Pointer to a color structure which will contain
  8553. *                      the color information.
  8554. *    
  8555. *   RESULT
  8556. *     error - RCNOERROR    if all went well.
  8557. *            RCNOMESH     if the handle is not valid.
  8558. *
  8559. *   EXAMPLE
  8560. *    error = meshLightColorGetubc(meshhandle,&mycolor);
  8561. *
  8562. *   NOTES
  8563. *    The light will be used by some file formats only,
  8564. *    and for 2D or display functions.
  8565. *
  8566. *   BUGS
  8567. * 
  8568. *   SEE ALSO
  8569. *     meshLightColorSet(),meshLightPositionSet()
  8570. *    meshLightPositionGet()
  8571. * 
  8572. ******************************************************************************
  8573. *
  8574. */
  8575. ULONG __saveds ASM meshLightColorGetubc(register __d1 ULONG meshhandle,
  8576.                                         register __a0 TTDOColorub *color) {
  8577.     TTDOMesh        *mesh=NULL;
  8578.     TTDOColorub    *mcolor=NULL;
  8579.     
  8580.     // make a copy of color, a0 is a scratch register
  8581.     mcolor=color;
  8582.  
  8583.     mesh=(TTDOMesh *) meshhandle;
  8584.     if(mesh==NULL) return(RCNOMESH);
  8585.  
  8586.     (*color)=mesh->light.color;
  8587.     
  8588.     return(RCNOERROR);
  8589. }
  8590.  
  8591. /****** tdo.library/meshBoundingBoxGetd ******************************************
  8592. * 
  8593. *   NAME    
  8594. *     meshBoundingBoxGetd -- Get the bounding box of the mesh.
  8595. * 
  8596. *   SYNOPSIS
  8597. *    error = meshBoundingBoxGetd( meshhandle,bbox )
  8598. *                                 D1          A0
  8599. *
  8600. *    ULONG meshBoundingBoxGetd
  8601. *         ( ULONG,TTDOBBoxd * );
  8602. *
  8603. *   FUNCTION
  8604. *    The bounding box of the mesh will be written in the passed BBox structure.
  8605. * 
  8606. *   INPUTS
  8607. *     meshhandle      - A valid handle of a mesh.
  8608. *    bbox            - Pointer to a bbox structure which will contain
  8609. *                      the bounding box informations.
  8610. *    
  8611. *   RESULT
  8612. *     error - RCNOERROR    if all went well.
  8613. *            RCNOMESH     if the handle is not valid.
  8614. *
  8615. *   EXAMPLE
  8616. *    error = meshBoundingBoxGetd(meshhandle,&mybbox);
  8617. *
  8618. *   NOTES
  8619. *
  8620. *   BUGS
  8621. * 
  8622. *   SEE ALSO
  8623. * 
  8624. ******************************************************************************
  8625. *
  8626. */
  8627. ULONG __saveds ASM meshBoundingBoxGetd(register __d1 ULONG meshhandle,
  8628.                                         register __a0 TTDOBBoxd *bbox) {
  8629.     TTDOMesh        *mesh=NULL;
  8630.     TTDOBBoxd        *mbbox=NULL;
  8631.     
  8632.     // make a copy of bbox, a0 is a scratch register
  8633.     mbbox=bbox;
  8634.   
  8635.     mesh=(TTDOMesh *) meshhandle;
  8636.     if(mesh==NULL) return(RCNOMESH);
  8637.  
  8638.     (*mbbox)=mesh->bBox;
  8639.     
  8640.     return(RCNOERROR);
  8641. }
  8642.  
  8643. /****** tdo.library/meshBoundingBoxGetf ******************************************
  8644. * 
  8645. *   NAME    
  8646. *     meshBoundingBoxGetf -- Get the bounding box of the mesh.
  8647. * 
  8648. *   SYNOPSIS
  8649. *    error = meshBoundingBoxGetf( meshhandle,bbox )
  8650. *                                 D1          A0
  8651. *
  8652. *    ULONG meshBoundingBoxGetf
  8653. *         ( ULONG,TTDOBBoxf * );
  8654. *
  8655. *   FUNCTION
  8656. *    The bounding box of the mesh will be written in the passed BBox structure.
  8657. * 
  8658. *   INPUTS
  8659. *     meshhandle      - A valid handle of a mesh.
  8660. *    bbox            - Pointer to a bbox structure which will contain
  8661. *                      the bounding box informations.
  8662. *    
  8663. *   RESULT
  8664. *     error - RCNOERROR    if all went well.
  8665. *            RCNOMESH     if the handle is not valid.
  8666. *
  8667. *   EXAMPLE
  8668. *    error = meshBoundingBoxGetf(meshhandle,&mybbox);
  8669. *
  8670. *   NOTES
  8671. *
  8672. *   BUGS
  8673. * 
  8674. *   SEE ALSO
  8675. * 
  8676. ******************************************************************************
  8677. *
  8678. */
  8679. ULONG __saveds ASM meshBoundingBoxGetf(register __d1 ULONG meshhandle,
  8680.                                         register __a0 TTDOBBoxf *bbox) {
  8681.     TTDOMesh        *mesh=NULL;
  8682.     TTDOBBoxf        *mbbox=NULL;
  8683.     
  8684.     // make a copy of bbox, a0 is a scratch register
  8685.     mbbox=bbox;
  8686.   
  8687.     mesh=(TTDOMesh *) meshhandle;
  8688.     if(mesh==NULL) return(RCNOMESH);
  8689.  
  8690.     mbbox->front=mesh->bBox.front;
  8691.     mbbox->rear=mesh->bBox.rear;
  8692.     mbbox->left=mesh->bBox.left;
  8693.     mbbox->right=mesh->bBox.right;
  8694.     mbbox->top=mesh->bBox.top;
  8695.     mbbox->bottom=mesh->bBox.bottom;
  8696.  
  8697.     return(RCNOERROR);
  8698. }
  8699.  
  8700. /****** tdo.library/meshSave3D ******************************************
  8701. * 
  8702. *   NAME    
  8703. *     meshSave3D -- Saves the mesh as 3D file..
  8704. *
  8705. *   SYNOPSIS
  8706. *    error = meshSave3D( meshhandle,formatname,filename,screen )
  8707. *                        D1         D2         D3        A0
  8708. *
  8709. *    ULONG meshSave3D
  8710. *         ( ULONG,STRPTR,STRPTR,struct Screen * );
  8711. *
  8712. *   FUNCTION
  8713. *    The mesh will be saved in the specified 3d file format.
  8714. * 
  8715. *   INPUTS
  8716. *     meshhandle  - A valid handle of a mesh.
  8717. *    formatname  - A valid 3D saver name, which specifies the output format.
  8718. *    filename    - Name and path of the file.
  8719. *    screen      - The screen of the caller, or NULL if no one or no options.
  8720. *    
  8721. *   RESULT
  8722. *    error - RCNOERROR            if all went well.
  8723. *            RCNOMESH             if the handle is not valid.
  8724. *            RCUNKNOWNFORMAT      if the file format is not known.
  8725. *            RCSAVEROPEN          if the saver library could not be opened.
  8726. *            tdo3X errors         if an error occured in the extension module.
  8727. *            IoErr()              if possible to catch it, you will get its codes.
  8728. *
  8729. *   EXAMPLE
  8730. *    error = meshSave3D(meshhandle,formatname,"ram:test",NULL);
  8731. *
  8732. *   NOTES
  8733. *    No file existence tests are made here! Existent files will be overwritten.
  8734. *
  8735. *   BUGS
  8736. * 
  8737. *   SEE ALSO
  8738. *    meshLoad3D(),meshSave2D(),
  8739. *    meshLoad2D()
  8740. * 
  8741. ******************************************************************************
  8742. *
  8743. */
  8744. ULONG __saveds ASM meshSave3D(register __d1 ULONG meshhandle,
  8745.                                 register __d2 STRPTR formatname,
  8746.                                 register __d3 STRPTR filename,
  8747.                                 register __a0 struct Screen *screen) {
  8748.     TTDOMesh        *mesh;
  8749.     ULONG            mmeshhandle;
  8750.     struct Screen    *mscreen;
  8751.     ULONG            retcode=RCNOERROR;
  8752.     UBYTE            i;
  8753.  
  8754.     // make a copy of screen, a0 is a scratch register
  8755.     mmeshhandle=meshhandle;
  8756.  
  8757.     // make a copy of screen, a0 is a scratch register
  8758.     mscreen=screen;
  8759.     
  8760.     mesh = (TTDOMesh *) meshhandle;
  8761.     if(mesh==NULL) return(RCNOMESH);    
  8762.  
  8763.     /*
  8764.     ** Check if the filetype is valid
  8765.     */
  8766.     if(c3dsNames==NULL) return(RCUNKNOWNFORMAT);
  8767.     i=0;
  8768.     while(c3dsNames[i]!=NULL && strcmp(c3dsNames[i],formatname)!=0) {i++};
  8769.     if(c3dsNames[i]==NULL) return(RCUNKNOWNFORMAT);
  8770.     
  8771.     /*
  8772.     ** If no camera and light position was given, set it to default now
  8773.     */
  8774.     if (!(mesh->camera.position.x &&
  8775.          mesh->camera.position.y &&
  8776.          mesh->camera.position.z &&
  8777.          mesh->camera.lookat.x &&
  8778.          mesh->camera.lookat.y &&
  8779.          mesh->camera.lookat.z &&
  8780.          mesh->light.position.x &&
  8781.          mesh->light.position.y &&
  8782.          mesh->light.position.z)) setCameraLight(mesh);
  8783.  
  8784.     /*
  8785.     ** Open the output library and write the mesh
  8786.     */
  8787.     if((x3Base=(APTR) OpenLibrary(c3dsLib[i],0))==NULL) {
  8788.         return(RCSAVEROPEN);
  8789.     }
  8790.  
  8791.     retcode=tdo3XSave(mmeshhandle,filename,NULL);
  8792.  
  8793.     CloseLibrary((APTR)x3Base);
  8794.  
  8795.     return(RCNOERROR);
  8796. }
  8797.  
  8798. /****** tdo.library/meshLoad3D ******************************************
  8799. * 
  8800. *   NAME    
  8801. *     meshLoad3D -- Loads a 3D file into a mesh.
  8802. *
  8803. *   SYNOPSIS
  8804. *    error = meshLoad3D( meshhandle,filename,erroffset,screen )
  8805. *                        D1         D3       D4         A0
  8806. *
  8807. *    ULONG meshLoad3D
  8808. *         ( ULONG *,STRPTR,struct Screen * );
  8809. *
  8810. *   FUNCTION
  8811. *    A new mesh will be created and filled up with the data
  8812. *    found in the 3D file.
  8813. * 
  8814. *   INPUTS
  8815. *     meshhandle  - Pointer which will contain the new mesh.
  8816. *    filename    - Name and path of the file.
  8817. *    erroffset   - Offset in lines or bytes where an error occured.
  8818. *    screen      - The screen of the caller, or NULL if no one or no options.
  8819. *    
  8820. *   RESULT
  8821. *    error - RCNOERROR            if all went well.
  8822. *            RCNOMESH             if no new mesh could be created.
  8823. *            RCUNKNOWNFORMAT      if the file format is not known.
  8824. *            RCLOADEROPEN         if a loader library could not be opened.
  8825. *            tdo3X errors         if an error occured in the extension module.
  8826. *            IoErr()              if possible to catch it, you will get its codes.
  8827. *
  8828. *   EXAMPLE
  8829. *    error = meshLoad3D(&meshhandle,"ram:test",NULL);
  8830. *
  8831. *   NOTES
  8832. *
  8833. *   BUGS
  8834. * 
  8835. *   SEE ALSO
  8836. *    meshSave3D(),meshSave2D(),
  8837. *    meshLoad2D()
  8838. * 
  8839. ******************************************************************************
  8840. *
  8841. */
  8842. ULONG __saveds ASM meshLoad3D(register __d1 ULONG *meshhandle,
  8843.                                 register __d3 STRPTR filename,
  8844.                                 register __d4 ULONG *erroffset,
  8845.                                 register __a0 struct Screen *screen) {
  8846.     ULONG            *mmeshhandle;
  8847.     struct Screen    *mscreen;
  8848.     ULONG            retcode=RCNOERROR;
  8849.     UBYTE            i;
  8850.  
  8851.     // make a copy of meshhandle, d1 is a scratch register
  8852.     mmeshhandle=meshhandle;
  8853.  
  8854.     // make a copy of screen, a0 is a scratch register
  8855.     mscreen=screen;
  8856.  
  8857.     // check if the input file can be recognized by someone
  8858.     if(c3dlNames==NULL) return(RCUNKNOWNFORMAT);
  8859.     i=0;
  8860.     retcode=RCNOERROR+1;
  8861.     while(c3dlLib[i]!=NULL && retcode!=RCNOERROR) {
  8862.         if((x3Base=(APTR) OpenLibrary(c3dlLib[i],0))==NULL) {
  8863.             return(RCLOADEROPEN);
  8864.         }
  8865.  
  8866.         retcode=tdo3XCheckFile(filename);
  8867.  
  8868.         // close the library if it is the false one, and increment i
  8869.         if(retcode!=RCNOERROR) {
  8870.             CloseLibrary((APTR)x3Base);
  8871.             i++;
  8872.         }
  8873.     };
  8874.     
  8875.     // did we find something ?
  8876.     if(retcode!=RCNOERROR) {
  8877.         CloseLibrary((APTR)x3Base);
  8878.         return(retcode);
  8879.     }
  8880.  
  8881.     // create a new mesh
  8882. //    if(((*mmeshhandle)=meshNew())==0) {
  8883. //        CloseLibrary((APTR)x3Base);
  8884. //        return(RCNOMESH);
  8885. //    }
  8886.     
  8887.     retcode=tdo3XLoad((*mmeshhandle),filename,erroffset,mscreen);
  8888.  
  8889.     // in error case, delete the mesh
  8890.     if(retcode!=RCNOERROR) {
  8891. //        meshDelete((*mmeshhandle));
  8892.         (*meshhandle)=0;
  8893.     }
  8894.  
  8895.     CloseLibrary((APTR)x3Base);
  8896.  
  8897.     return(retcode);
  8898. }
  8899.  
  8900.  
  8901. /*
  8902. ULONG __saveds ASM tdogetcur(register __a6 struct tdoBase *tdoBase) {
  8903.  return(tdoBase->tdb_current);
  8904. }
  8905. */
  8906.  
  8907.  
  8908. /*
  8909. TODO
  8910.  
  8911. Lightwave,Imagine,Videoscape  groessen/anzahl checks fertigmachen !!
  8912.  
  8913. Material mehr parameter, brechungsindex, reflektion, ...
  8914.  
  8915. */
  8916.  
  8917. /************************* End of file ******************************/
  8918.  
  8919.